Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

21 files changed, 65005 insertions, 0 deletions

diff --git a/toolkit/components/reputationservice/ApplicationReputation.cpp b/toolkit/components/reputationservice/ApplicationReputation.cpp
new file mode 100644
index 0000000000..cc4045d5ad
--- /dev/null
+++ b/toolkit/components/reputationservice/ApplicationReputation.cpp
@@ -0,0 +1,1987 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// See
+// https://wiki.mozilla.org/Security/Features/Application_Reputation_Design_Doc
+// for a description of Chrome's implementation of this feature.
+#include "ApplicationReputation.h"
+#include "chrome/common/safe_browsing/csd.pb.h"
+
+#include "nsIArray.h"
+#include "nsIApplicationReputation.h"
+#include "nsIChannel.h"
+#include "nsIHttpChannel.h"
+#include "nsIIOService.h"
+#include "nsIObserverService.h"
+#include "nsISimpleEnumerator.h"
+#include "nsIStreamListener.h"
+#include "nsIStringStream.h"
+#include "nsITimer.h"
+#include "nsIUploadChannel2.h"
+#include "nsIURI.h"
+#include "nsIURL.h"
+#include "nsIUrlClassifierDBService.h"
+#include "nsIURLFormatter.h"
+#include "nsIX509Cert.h"
+#include "nsIX509CertDB.h"
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/Components.h"
+#include "mozilla/ErrorNames.h"
+#include "mozilla/LoadContext.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/Services.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/intl/LocaleService.h"
+
+#include "nsCOMPtr.h"
+#include "nsDebug.h"
+#include "nsDependentSubstring.h"
+#include "nsError.h"
+#include "nsLocalFileCommon.h"
+#include "nsNetCID.h"
+#include "nsReadableUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "nsThreadUtils.h"
+
+#include "nsIContentPolicy.h"
+#include "nsICryptoHash.h"
+#include "nsILoadInfo.h"
+#include "nsContentUtils.h"
+#include "nsWeakReference.h"
+#include "nsIRedirectHistoryEntry.h"
+
+#include "ApplicationReputationTelemetryUtils.h"
+
+using mozilla::ArrayLength;
+using mozilla::BasePrincipal;
+using mozilla::OriginAttributes;
+using mozilla::Preferences;
+using mozilla::TimeStamp;
+using mozilla::intl::LocaleService;
+using mozilla::Telemetry::Accumulate;
+using mozilla::Telemetry::AccumulateCategorical;
+using safe_browsing::ClientDownloadRequest;
+using safe_browsing::ClientDownloadRequest_CertificateChain;
+using safe_browsing::ClientDownloadRequest_Resource;
+using safe_browsing::ClientDownloadRequest_SignatureInfo;
+
+// Preferences that we need to initialize the query.
+#define PREF_SB_APP_REP_URL "browser.safebrowsing.downloads.remote.url"
+#define PREF_SB_MALWARE_ENABLED "browser.safebrowsing.malware.enabled"
+#define PREF_SB_DOWNLOADS_ENABLED "browser.safebrowsing.downloads.enabled"
+#define PREF_SB_DOWNLOADS_REMOTE_ENABLED \
+  "browser.safebrowsing.downloads.remote.enabled"
+#define PREF_SB_DOWNLOADS_REMOTE_TIMEOUT \
+  "browser.safebrowsing.downloads.remote.timeout_ms"
+#define PREF_DOWNLOAD_BLOCK_TABLE "urlclassifier.downloadBlockTable"
+#define PREF_DOWNLOAD_ALLOW_TABLE "urlclassifier.downloadAllowTable"
+
+// Preferences that are needed to action the verdict.
+#define PREF_BLOCK_DANGEROUS \
+  "browser.safebrowsing.downloads.remote.block_dangerous"
+#define PREF_BLOCK_DANGEROUS_HOST \
+  "browser.safebrowsing.downloads.remote.block_dangerous_host"
+#define PREF_BLOCK_POTENTIALLY_UNWANTED \
+  "browser.safebrowsing.downloads.remote.block_potentially_unwanted"
+#define PREF_BLOCK_UNCOMMON \
+  "browser.safebrowsing.downloads.remote.block_uncommon"
+
+// MOZ_LOG=ApplicationReputation:5
+mozilla::LazyLogModule ApplicationReputationService::prlog(
+    "ApplicationReputation");
+#define LOG(args) \
+  MOZ_LOG(ApplicationReputationService::prlog, mozilla::LogLevel::Debug, args)
+#define LOG_ENABLED() \
+  MOZ_LOG_TEST(ApplicationReputationService::prlog, mozilla::LogLevel::Debug)
+
+/**
+ * Our detection of executable/binary files uses 3 lists:
+ * - kNonBinaryExecutables (below)
+ * - kBinaryFileExtensions (below)
+ * - sExecutableExts (in nsLocalFileCommon)
+ *
+ * On Windows, the `sExecutableExts` list is used to determine whether files
+ * count as executable. For executable files, we will not offer an "open with"
+ * option when downloading, only "save as".
+ *
+ * On all platforms, the combination of these lists is used to determine
+ * whether files should be subject to application reputation checks.
+ * Specifically, all files with extensions that:
+ * - are in kBinaryFileExtensions, or
+ * - are in sExecutableExts **and not in kNonBinaryExecutables**
+ *
+ * will be subject to checks.
+ *
+ * There are tests that verify that these lists are sorted and that extensions
+ * never appear in both the sExecutableExts and kBinaryFileExtensions lists.
+ *
+ * When adding items to any lists:
+ * - please prefer adding to sExecutableExts unless it is imperative users can
+ *   (potentially automatically!) open such files with a helper application
+ *   without first saving them (and that outweighs any associated risk).
+ * - if adding executable items that shouldn't be submitted to apprep servers,
+ *   add them to sExecutableExts and also to kNonBinaryExecutables.
+ * - always add an associated comment in the kBinaryFileExtensions list. Add
+ *   a commented-out entry with an `exec` annotation if you add the actual
+ *   entry in sExecutableExts.
+ *
+ * When removing items please consider whether items should still be in the
+ * sExecutableExts list even if removing them from the kBinaryFileExtensions
+ * list, and vice versa.
+ *
+ * Note that there is a GTest that does its best to check some of these
+ * invariants that you'll likely need to update if you're modifying these
+ * lists.
+ */
+
+// Items that are in sExecutableExts but shouldn't be submitted for application
+// reputation checks.
+/* static */
+const char* const ApplicationReputationService::kNonBinaryExecutables[] = {
+    // clang-format off
+    ".ad",
+    ".afploc",
+    ".air",
+    ".atloc",
+    ".ftploc",
+    // clang-format on
+};
+
+// Items that should be submitted for application reputation checks that users
+// are able to open immediately (without first saving and then finding the
+// file). If users shouldn't be able to open them immediately, add to
+// sExecutableExts instead (see also the docstring comment above!).
+/* static */
+const char* const ApplicationReputationService::kBinaryFileExtensions[] = {
+    // Originally extracted from the "File Type Policies" Chrome extension
+    // Items listed with an `exec` comment are in the sExecutableExts list in
+    // nsLocalFileCommon.h .
+    //".001",
+    //".7z",
+    //".ace",
+    //".accda", exec       // MS Access database
+    //".accdb", exec       // MS Access database
+    //".accde", exec       // MS Access database
+    //".accdr", exec       // MS Access database
+    ".action",  // Mac script
+    //".ad", exec // Windows
+    //".ade", exec  // MS Access
+    //".adp", exec // MS Access
+    //".air", exec // Adobe AIR installer; excluded from apprep checks.
+    ".apk",  // Android package
+    //".app", exec  // Executable application
+    ".applescript",
+    //".application", exec // MS ClickOnce
+    //".appref-ms", exec // MS ClickOnce
+    //".appx", exec
+    //".appxbundle", exec
+    //".arc",
+    //".arj",
+    ".as",  // Mac archive
+    //".asp", exec  // Windows Server script
+    ".asx",  // Windows Media Player
+    //".b64",
+    //".balz",
+    //".bas", exec  // Basic script
+    ".bash",  // Linux shell
+    //".bat", exec  // Windows shell
+    //".bhx",
+    ".bin",
+    ".btapp",      // uTorrent and Transmission
+    ".btinstall",  // uTorrent and Transmission
+    ".btkey",      // uTorrent and Transmission
+    ".btsearch",   // uTorrent and Transmission
+    ".btskin",     // uTorrent and Transmission
+    ".bz",         // Linux archive (bzip)
+    ".bz2",        // Linux archive (bzip2)
+    ".bzip2",      // Linux archive (bzip2)
+    ".cab",        // Windows archive
+    ".caction",    // Automator action
+    ".cdr",        // Mac disk image
+    //".cer", exec // Signed certificate file
+    ".cfg",  // Windows
+    ".chi",  // Windows Help
+    //".chm", exec // Windows Help
+    ".class",  // Java
+    //".cmd", exec // Windows executable
+    //".com", exec // Windows executable
+    ".command",        // Mac script
+    ".configprofile",  // Configuration file for Apple systems
+    ".cpgz",           // Mac archive
+    ".cpi",            // Control Panel Item. Executable used for adding icons
+                       // to Control Panel
+    //".cpio",
+    //".cpl", exec  // Windows executable
+    //".crt", exec  // Windows signed certificate
+    ".crx",  // Chrome extensions
+    ".csh",  // Linux shell
+    //".csv",
+    ".dart",        // Mac disk image
+    ".dc42",        // Apple DiskCopy Image
+    ".deb",         // Linux package
+    ".definition",  // Automator action
+    ".desktop",     // A shortcut that runs other files
+    //".der", exec  // Signed certificate
+    ".dex",    // Android
+    ".dht",    // HTML
+    ".dhtm",   // HTML
+    ".dhtml",  // HTML
+    //".diagcab", exec // Executable windows archive, like .cab
+    ".diskcopy42",  // Apple DiskCopy Image
+    ".dll",         // Windows executable
+    ".dmg",         // Mac disk image
+    ".dmgpart",     // Mac disk image
+    ".doc",         // MS Office
+    ".docb",        // MS Office
+    ".docm",        // MS Word
+    ".docx",        // MS Word
+    ".dot",         // MS Word
+    ".dotm",        // MS Word
+    ".dott",        // MS Office
+    ".dotx",        // MS Word
+    ".drv",         // Windows driver
+    ".dvdr",        // Mac Disk image
+    ".dylib",       // Mach object dynamic library file
+    ".efi",         // Firmware
+    ".eml",         // MS Outlook
+    //".exe", exec // Windows executable
+    //".fat",
+    //".fileloc", exec  // Apple finder internet location data file
+    ".fon",  // Windows font
+    //".fxp", exec // MS FoxPro
+    ".gadget",  // Windows
+    //".gif",
+    ".grp",   // Windows
+    ".gz",    // Linux archive (gzip)
+    ".gzip",  // Linux archive (gzip)
+    ".hfs",   // Mac disk image
+    //".hlp", exec // Windows Help
+    ".hqx",  // Mac archive
+    //".hta", exec // HTML trusted application
+    ".htm", ".html",
+    ".htt",  // MS HTML template
+    //".ica",
+    ".img",      // Mac disk image
+    ".imgpart",  // Mac disk image
+    //".inf", exec // Windows installer
+    //".inetloc", exec  // Apple finder internet location data file
+    ".ini",  // Generic config file
+    //".ins", exec // IIS config
+    ".internetconnect",  // Configuration file for Apple system
+    //".inx", // InstallShield
+    ".iso",  // CD image
+             //".isp", exec // IIS config
+             //".isu", // InstallShield
+             //".jar", exec // Java
+#ifndef MOZ_ESR
+//".jnlp", exec // Java
+#endif
+    //".job", // Windows
+    //".jpg",
+    //".jpeg",
+    //".js", exec  // JavaScript script
+    //".jse", exec // JScript
+    ".ksh",  // Linux shell
+    //".lha",
+    //".lnk", exec // Windows
+    ".local",  // Windows
+    //".lpaq1",
+    //".lpaq5",
+    //".lpaq8",
+    //".lzh",
+    //".lzma",
+    //".mad", exec  // MS Access
+    //".maf", exec  // MS Access
+    //".mag", exec  // MS Access
+    //".mam", exec  // MS Access
+    ".manifest",  // Windows
+    //".maq", exec  // MS Access
+    //".mar", exec  // MS Access
+    //".mas", exec  // MS Access
+    //".mat", exec  // MS Access
+    //".mau", exec  // Media attachment
+    //".mav", exec  // MS Access
+    //".maw", exec  // MS Access
+    //".mda", exec  // MS Access
+    //".mdb", exec  // MS Access
+    //".mde", exec  // MS Access
+    //".mdt", exec  // MS Access
+    //".mdw", exec  // MS Access
+    //".mdz", exec  // MS Access
+    ".mht",    // MS HTML
+    ".mhtml",  // MS HTML
+    ".mim",    // MS Mail
+    //".mkv",
+    ".mmc",           // MS Office
+    ".mobileconfig",  // Configuration file for Apple systems
+    ".mof",           // Windows
+    //".mov",
+    //".mp3",
+    //".mp4",
+    ".mpkg",  // Mac installer
+    //".msc", exec  // Windows executable
+    ".msg",  // MS Outlook
+    //".msh", exec  // Windows shell
+    //".msh1", exec // Windows shell
+    //".msh1xml", exec  // Windows shell
+    //".msh2", exec // Windows shell
+    //".msh2xml", exec // Windows shell
+    //".mshxml", exec // Windows
+    //".msi", exec  // Windows installer
+    //".msix", exec // Windows installer
+    //".msixbundle", exec // Windows installer
+    //".msp", exec  // Windows installer
+    //".mst", exec  // Windows installer
+    ".ndif",            // Mac disk image
+    ".networkconnect",  // Configuration file for Apple systems
+    //".ntfs", // 7z
+    ".ocx",  // ActiveX
+    //".ops", exec  // MS Office
+    ".osas",  // AppleScript
+    ".osax",  // AppleScript
+    //".out", // Linux binary
+    ".oxt",  // OpenOffice extension, can execute arbitrary code
+    //".package",
+    //".paf", // PortableApps package
+    //".paq8f",
+    //".paq8jd",
+    //".paq8l",
+    //".paq8o",
+    ".partial",  // Downloads
+    ".pax",      // Mac archive
+    //".pcd", exec     // Microsoft Visual Test
+    ".pdf",  // Adobe Acrobat
+    //".pea",
+    ".pet",  // Linux package
+    //".pif", exec // Windows
+    ".pkg",  // Mac installer
+    ".pl",   // Perl script
+    //".plg", exec // MS Visual Studio
+    //".png",
+    ".pot",   // MS PowerPoint
+    ".potm",  // MS PowerPoint
+    ".potx",  // MS PowerPoint
+    ".ppam",  // MS PowerPoint
+    ".pps",   // MS PowerPoint
+    ".ppsm",  // MS PowerPoint
+    ".ppsx",  // MS PowerPoint
+    ".ppt",   // MS PowerPoint
+    ".pptm",  // MS PowerPoint
+    ".pptx",  // MS PowerPoint
+    //".prf", exec // MS Outlook
+    //".prg", exec // Windows
+    ".ps1",     // Windows shell
+    ".ps1xml",  // Windows shell
+    ".ps2",     // Windows shell
+    ".ps2xml",  // Windows shell
+    ".psc1",    // Windows shell
+    ".psc2",    // Windows shell
+    //".pst", exec // MS Outlook
+    ".pup",  // Linux package
+    ".py",   // Python script
+    ".pyc",  // Python binary
+    ".pyd",  // Equivalent of a DLL, for python libraries
+    ".pyo",  // Compiled python code
+    ".pyw",  // Python GUI
+    //".quad",
+    //".r00",
+    //".r01",
+    //".r02",
+    //".r03",
+    //".r04",
+    //".r05",
+    //".r06",
+    //".r07",
+    //".r08",
+    //".r09",
+    //".r10",
+    //".r11",
+    //".r12",
+    //".r13",
+    //".r14",
+    //".r15",
+    //".r16",
+    //".r17",
+    //".r18",
+    //".r19",
+    //".r20",
+    //".r21",
+    //".r22",
+    //".r23",
+    //".r24",
+    //".r25",
+    //".r26",
+    //".r27",
+    //".r28",
+    //".r29",
+    //".rar",
+    ".rb",  // Ruby script
+    //".reg", exec  // Windows Registry
+    ".rels",  // MS Office
+    //".rgs", // Windows Registry
+    ".rpm",  // Linux package
+    ".rtf",  // MS Office
+    //".run", // Linux shell
+    //".scf", exec         // Windows shell
+    ".scpt",   // AppleScript
+    ".scptd",  // AppleScript
+    //".scr", exec         // Windows
+    //".sct", exec         // Windows shell
+    ".search-ms",  // Windows
+    ".seplugin",   // AppleScript
+    ".service",    // Systemd service unit file
+    //".settingcontent-ms", exec // Windows settings
+    ".sh",    // Linux shell
+    ".shar",  // Linux shell
+    //".shb", exec         // Windows
+    //".shs", exec         // Windows shell
+    ".sht",           // HTML
+    ".shtm",          // HTML
+    ".shtml",         // HTML
+    ".sldm",          // MS PowerPoint
+    ".sldx",          // MS PowerPoint
+    ".slk",           // MS Excel
+    ".slp",           // Linux package
+    ".smi",           // Mac disk image
+    ".sparsebundle",  // Mac disk image
+    ".sparseimage",   // Mac disk image
+    ".spl",           // Adobe Flash
+    //".squashfs",
+    ".svg",
+    ".swf",   // Adobe Flash
+    ".swm",   // Windows Imaging
+    ".sys",   // Windows
+    ".tar",   // Linux archive
+    ".taz",   // Linux archive (bzip2)
+    ".tbz",   // Linux archive (bzip2)
+    ".tbz2",  // Linux archive (bzip2)
+    ".tcsh",  // Linux shell
+    //".tif",
+    ".tgz",  // Linux archive (gzip)
+    //".toast", // Roxio disk image
+    ".torrent",  // Bittorrent
+    ".tpz",      // Linux archive (gzip)
+    //".txt",
+    ".txz",  // Linux archive (xz)
+    ".tz",   // Linux archive (gzip)
+    //".u3p", // U3 Smart Apps
+    ".udf",   // MS Excel
+    ".udif",  // Mac disk image
+    //".url", exec  // Windows
+    //".uu",
+    //".uue",
+    //".vb", exec  // Visual Basic script
+    //".vbe", exec // Visual Basic script
+    //".vbs", exec // Visual Basic script
+    //".vbscript", // Visual Basic script
+    //".vdx", exec // MS Visio
+    ".vhd",   // Windows virtual hard drive
+    ".vhdx",  // Windows virtual hard drive
+    ".vmdk",  // VMware virtual disk
+    //".vsd", exec  // MS Visio
+    //".vsdm", exec // MS Visio
+    //".vsdx", exec // MS Visio
+    //".vsmacros", exec  // MS Visual Studio
+    //".vss",  exec  // MS Visio
+    //".vssm", exec  // MS Visio
+    //".vssx", exec  // MS Visio
+    //".vst",  exec  // MS Visio
+    //".vstm", exec  // MS Visio
+    //".vstx", exec  // MS Visio
+    //".vsw",  exec  // MS Visio
+    //".vsx",  exec  // MS Visio
+    //".vtx",  exec  // MS Visio
+    //".wav",
+    //".webloc",  // MacOS website location file
+    //".webp",
+    ".website",   // Windows
+    ".wflow",     // Automator action
+    ".wim",       // Windows Imaging
+    ".workflow",  // Mac Automator
+    //".wrc", // FreeArc archive
+    //".ws",  exec  // Windows script
+    //".wsc", exec  // Windows script
+    //".wsf", exec  // Windows script
+    //".wsh", exec  // Windows script
+    ".xar",   // MS Excel
+    ".xbap",  // XAML Browser Application
+    ".xht", ".xhtm", ".xhtml",
+    ".xip",   // Mac archive
+    ".xla",   // MS Excel
+    ".xlam",  // MS Excel
+    ".xldm",  // MS Excel
+    //".xll", exec  // MS Excel
+    ".xlm",     // MS Excel
+    ".xls",     // MS Excel
+    ".xlsb",    // MS Excel
+    ".xlsm",    // MS Excel
+    ".xlsx",    // MS Excel
+    ".xlt",     // MS Excel
+    ".xltm",    // MS Excel
+    ".xltx",    // MS Excel
+    ".xlw",     // MS Excel
+    ".xml",     // MS Excel
+    ".xnk",     // MS Exchange
+    ".xrm-ms",  // Windows
+    ".xsd",     // XML schema definition
+    ".xsl",     // XML Stylesheet
+    //".xxe",
+    ".xz",     // Linux archive (xz)
+    ".z",      // InstallShield
+#ifdef XP_WIN  // disable on Mac/Linux, see 1167493
+    ".zip",    // Generic archive
+#endif
+    ".zipx",  // WinZip
+              //".zpaq",
+};
+
+static const char* const kMozNonBinaryExecutables[] = {
+    ".001", ".7z",   ".ace",  ".arc",   ".arj",    ".b64",      ".balz",
+    ".bhx", ".cpio", ".fat",  ".lha",   ".lpaq1",  ".lpaq5",    ".lpaq8",
+    ".lzh", ".lzma", ".ntfs", ".paq8f", ".paq8jd", ".paq8l",    ".paq8o",
+    ".pea", ".quad", ".r00",  ".r01",   ".r02",    ".r03",      ".r04",
+    ".r05", ".r06",  ".r07",  ".r08",   ".r09",    ".r10",      ".r11",
+    ".r12", ".r13",  ".r14",  ".r15",   ".r16",    ".r17",      ".r18",
+    ".r19", ".r20",  ".r21",  ".r22",   ".r23",    ".r24",      ".r25",
+    ".r26", ".r27",  ".r28",  ".r29",   ".rar",    ".squashfs", ".uu",
+    ".uue", ".wrc",  ".xxe",  ".zpaq",  ".toast",
+};
+
+static const char* const kSafeFileExtensions[] = {
+    ".jpg",  ".jpeg", ".mp3",      ".mp4",  ".png",  ".csv",  ".ica",
+    ".gif",  ".txt",  ".package",  ".tif",  ".webp", ".mkv",  ".wav",
+    ".mov",  ".paf",  ".vbscript", ".ad",   ".inx",  ".isu",  ".job",
+    ".rgs",  ".u3p",  ".out",      ".run",  ".bmp",  ".css",  ".ehtml",
+    ".flac", ".ico",  ".jfif",     ".m4a",  ".m4v",  ".mpeg", ".mpg",
+    ".oga",  ".ogg",  ".ogm",      ".ogv",  ".opus", ".pjp",  ".pjpeg",
+    ".svgz", ".text", ".tiff",     ".weba", ".webm", ".xbm",
+};
+
+enum class LookupType { AllowlistOnly, BlocklistOnly, BothLists };
+
+// Define the reasons that download protection service accepts or blocks this
+// download. This is now used for telemetry purposes and xpcshell test. Please
+// also update the xpcshell-test if a reason is added.
+//
+// LocalWhitelist       : URL is found in the local whitelist
+// LocalBlocklist       : URL is found in the local blocklist
+// NonBinary            : The downloaded non-binary file is not found in the
+// local blocklist VerdictSafe          : Remote lookup reports the download is
+// safe VerdictUnknown       : Remote lookup reports unknown, we treat this as a
+// safe download VerdictDangerous     : Remote lookup reports the download is
+// dangerous VerdictDangerousHost : Remote lookup reports the download is from a
+// dangerous host VerdictUnwanted      : Remote lookup reports the download is
+// potentially unwatned VerdictUncommon      : Remote lookup reports the
+// download is uncommon VerdictUnrecognized  : The verdict type from remote
+// lookup is not defined in the csd.proto DangerousPrefOff     : The download is
+// dangerous, but the corresponding preference is off DangerousHostPrefOff : The
+// download is from a dangerous host, but the corresponding preference is off
+// UnwantedPrefOff      : The download is potentially unwanted, but the
+// corresponding preference is off UncommonPrefOff      : The download us
+// uncommon, but the coressponding preference is off NetworkError         :
+// There is an error while requesting remote lookup RemoteLookupDisabled :
+// Remote lookup is disabled or the remote lookup URL is empty InternalError :
+// An unexpected internal error DPDisabled           : Download protection is
+// disabled
+using Reason = mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_REASON;
+
+class PendingDBLookup;
+
+// A single use class private to ApplicationReputationService encapsulating an
+// nsIApplicationReputationQuery and an nsIApplicationReputationCallback. Once
+// created by ApplicationReputationService, it is guaranteed to call mCallback.
+// This class is private to ApplicationReputationService.
+class PendingLookup final : public nsIStreamListener,
+                            public nsITimerCallback,
+                            public nsINamed,
+                            public nsIObserver,
+                            public nsSupportsWeakReference {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIREQUESTOBSERVER
+  NS_DECL_NSISTREAMLISTENER
+  NS_DECL_NSITIMERCALLBACK
+  NS_DECL_NSINAMED
+  NS_DECL_NSIOBSERVER
+
+  // Constructor and destructor.
+  PendingLookup(nsIApplicationReputationQuery* aQuery,
+                nsIApplicationReputationCallback* aCallback);
+
+  // Start the lookup. The lookup may have 2 parts: local and remote. In the
+  // local lookup, PendingDBLookups are created to query the local allow and
+  // blocklists for various URIs associated with this downloaded file. In the
+  // event that no results are found, a remote lookup is sent to the Application
+  // Reputation server.
+  nsresult StartLookup();
+
+ private:
+  ~PendingLookup();
+
+  friend class PendingDBLookup;
+
+  // Telemetry states.
+  // Status of the remote response (valid or not).
+  enum SERVER_RESPONSE_TYPES {
+    SERVER_RESPONSE_VALID = 0,
+    SERVER_RESPONSE_FAILED = 1,
+    SERVER_RESPONSE_INVALID = 2,
+  };
+
+  // The target filename for the downloaded file.
+  nsCString mFileName;
+
+  // True if extension of this file matches any extension in the
+  // kBinaryFileExtensions or sExecutableExts list.
+  bool mIsBinaryFile;
+
+  // Number of blocklist and allowlist hits we have seen.
+  uint32_t mBlocklistCount;
+  uint32_t mAllowlistCount;
+
+  // The query containing metadata about the downloaded file.
+  nsCOMPtr<nsIApplicationReputationQuery> mQuery;
+
+  // The callback with which to report the verdict.
+  nsCOMPtr<nsIApplicationReputationCallback> mCallback;
+
+  // An array of strings created from certificate information used to whitelist
+  // the downloaded file.
+  nsTArray<nsCString> mAllowlistSpecs;
+  // The source URI of the download (i.e. final URI after any redirects).
+  nsTArray<nsCString> mAnylistSpecs;
+  // The referrer and possibly any redirects.
+  nsTArray<nsCString> mBlocklistSpecs;
+
+  // When we started this query
+  TimeStamp mStartTime;
+
+  // The channel used to talk to the remote lookup server
+  nsCOMPtr<nsIChannel> mChannel;
+
+  // Timer to abort this lookup if it takes too long
+  nsCOMPtr<nsITimer> mTimeoutTimer;
+
+  // A protocol buffer for storing things we need in the remote request. We
+  // store the resource chain (redirect information) as well as signature
+  // information extracted using the Windows Authenticode API, if the binary is
+  // signed.
+  ClientDownloadRequest mRequest;
+
+  // The response from the application reputation query. This is read in chunks
+  // as part of our nsIStreamListener implementation and may contain embedded
+  // NULLs.
+  nsCString mResponse;
+
+  // The clock records the start time of a remote lookup request, used by
+  // telemetry.
+  PRIntervalTime mTelemetryRemoteRequestStartMs;
+
+  // Returns the type of download binary for the file.
+  ClientDownloadRequest::DownloadType GetDownloadType(
+      const nsACString& aFilename);
+
+  // Clean up and call the callback. PendingLookup must not be used after this
+  // function is called.
+  nsresult OnComplete(uint32_t aVerdict, Reason aReason, nsresult aRv);
+
+  // Wrapper function for nsIStreamListener.onStopRequest to make it easy to
+  // guarantee calling the callback
+  nsresult OnStopRequestInternal(nsIRequest* aRequest, nsresult aResult,
+                                 uint32_t& aVerdict, Reason& aReason);
+
+  // Return the hex-encoded hash of the whole URI.
+  nsresult GetSpecHash(nsACString& aSpec, nsACString& hexEncodedHash);
+
+  // Strip url parameters, fragments, and user@pass fields from the URI spec
+  // using nsIURL. Hash data URIs and return blob URIs unfiltered.
+  nsresult GetStrippedSpec(nsIURI* aUri, nsACString& spec);
+
+  // Escape '/' and '%' in certificate attribute values.
+  nsCString EscapeCertificateAttribute(const nsACString& aAttribute);
+
+  // Escape ':' in fingerprint values.
+  nsCString EscapeFingerprint(const nsACString& aAttribute);
+
+  // Generate whitelist strings for the given certificate pair from the same
+  // certificate chain.
+  nsresult GenerateWhitelistStringsForPair(nsIX509Cert* certificate,
+                                           nsIX509Cert* issuer);
+
+  // Generate whitelist strings for the given certificate chain, which starts
+  // with the signer and may go all the way to the root cert.
+  nsresult GenerateWhitelistStringsForChain(
+      const ClientDownloadRequest_CertificateChain& aChain);
+
+  // For signed binaries, generate strings of the form:
+  // http://sb-ssl.google.com/safebrowsing/csd/certificate/
+  //   <issuer_cert_sha1_fingerprint>[/CN=<cn>][/O=<org>][/OU=<unit>]
+  // for each (cert, issuer) pair in each chain of certificates that is
+  // associated with the binary.
+  nsresult GenerateWhitelistStrings();
+
+  // Parse the XPCOM certificate lists and stick them into the protocol buffer
+  // version.
+  nsresult ParseCertificates(
+      const nsTArray<nsTArray<nsTArray<uint8_t>>>& aSigArray);
+
+  // Adds the redirects to mBlocklistSpecs to be looked up.
+  nsresult AddRedirects(nsIArray* aRedirects);
+
+  // Helper function to ensure that we call PendingLookup::LookupNext or
+  // PendingLookup::OnComplete.
+  nsresult DoLookupInternal();
+
+  // Looks up all the URIs that may be responsible for allowlisting or
+  // blocklisting the downloaded file. These URIs may include whitelist strings
+  // generated by certificates verifying the binary as well as the target URI
+  // from which the file was downloaded.
+  nsresult LookupNext();
+
+  // Sends a query to the remote application reputation service. Returns NS_OK
+  // on success.
+  nsresult SendRemoteQuery();
+
+  // Helper function to ensure that we always call the callback.
+  nsresult SendRemoteQueryInternal(Reason& aReason);
+};
+
+// A single-use class for looking up a single URI in the safebrowsing DB. This
+// class is private to PendingLookup.
+class PendingDBLookup final : public nsIUrlClassifierCallback {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIURLCLASSIFIERCALLBACK
+
+  // Constructor and destructor
+  explicit PendingDBLookup(PendingLookup* aPendingLookup);
+
+  // Look up the given URI in the safebrowsing DBs, optionally on both the allow
+  // list and the blocklist. If there is a match, call
+  // PendingLookup::OnComplete. Otherwise, call PendingLookup::LookupNext.
+  nsresult LookupSpec(const nsACString& aSpec, const LookupType& aLookupType);
+
+ private:
+  ~PendingDBLookup();
+
+  // The download appeared on the allowlist, blocklist, or no list (and thus
+  // could trigger a remote query.
+  enum LIST_TYPES {
+    ALLOW_LIST = 0,
+    BLOCK_LIST = 1,
+    NO_LIST = 2,
+  };
+
+  nsCString mSpec;
+  LookupType mLookupType;
+  RefPtr<PendingLookup> mPendingLookup;
+  nsresult LookupSpecInternal(const nsACString& aSpec);
+};
+
+NS_IMPL_ISUPPORTS(PendingDBLookup, nsIUrlClassifierCallback)
+
+PendingDBLookup::PendingDBLookup(PendingLookup* aPendingLookup)
+    : mLookupType(LookupType::BothLists), mPendingLookup(aPendingLookup) {
+  LOG(("Created pending DB lookup [this = %p]", this));
+}
+
+PendingDBLookup::~PendingDBLookup() {
+  LOG(("Destroying pending DB lookup [this = %p]", this));
+  mPendingLookup = nullptr;
+}
+
+nsresult PendingDBLookup::LookupSpec(const nsACString& aSpec,
+                                     const LookupType& aLookupType) {
+  LOG(("Checking principal %s [this=%p]", aSpec.Data(), this));
+  mSpec = aSpec;
+  mLookupType = aLookupType;
+  nsresult rv = LookupSpecInternal(aSpec);
+  if (NS_FAILED(rv)) {
+    nsAutoCString errorName;
+    mozilla::GetErrorName(rv, errorName);
+    LOG(("Error in LookupSpecInternal() [rv = %s, this = %p]", errorName.get(),
+         this));
+    return mPendingLookup->LookupNext();  // ignore this lookup and move to next
+  }
+  // LookupSpecInternal has called nsIUrlClassifierCallback.lookup, which is
+  // guaranteed to call HandleEvent.
+  return rv;
+}
+
+nsresult PendingDBLookup::LookupSpecInternal(const nsACString& aSpec) {
+  nsresult rv;
+
+  nsCOMPtr<nsIURI> uri;
+  nsCOMPtr<nsIIOService> ios = do_GetService(NS_IOSERVICE_CONTRACTID, &rv);
+  rv = ios->NewURI(aSpec, nullptr, nullptr, getter_AddRefs(uri));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  OriginAttributes attrs;
+  nsCOMPtr<nsIPrincipal> principal =
+      BasePrincipal::CreateContentPrincipal(uri, attrs);
+  if (!principal) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Check local lists to see if the URI has already been whitelisted or
+  // blacklisted.
+  LOG(("Checking DB service for principal %s [this = %p]", mSpec.get(), this));
+  nsCOMPtr<nsIUrlClassifierDBService> dbService =
+      mozilla::components::UrlClassifierDB::Service(&rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString tables;
+  nsAutoCString allowlist;
+  Preferences::GetCString(PREF_DOWNLOAD_ALLOW_TABLE, allowlist);
+  if ((mLookupType != LookupType::BlocklistOnly) && !allowlist.IsEmpty()) {
+    tables.Append(allowlist);
+  }
+  nsAutoCString blocklist;
+  Preferences::GetCString(PREF_DOWNLOAD_BLOCK_TABLE, blocklist);
+  if ((mLookupType != LookupType::AllowlistOnly) && !blocklist.IsEmpty()) {
+    if (!tables.IsEmpty()) {
+      tables.Append(',');
+    }
+    tables.Append(blocklist);
+  }
+  return dbService->Lookup(principal, tables, this);
+}
+
+NS_IMETHODIMP
+PendingDBLookup::HandleEvent(const nsACString& tables) {
+  // HandleEvent is guaranteed to call either:
+  // 1) PendingLookup::OnComplete if the URL matches the blocklist, or
+  // 2) PendingLookup::LookupNext if the URL does not match the blocklist.
+  // Blocklisting trumps allowlisting.
+  nsAutoCString blockList;
+  Preferences::GetCString(PREF_DOWNLOAD_BLOCK_TABLE, blockList);
+  if ((mLookupType != LookupType::AllowlistOnly) &&
+      FindInReadable(blockList, tables)) {
+    mPendingLookup->mBlocklistCount++;
+    Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_LOCAL, BLOCK_LIST);
+    LOG(("Found principal %s on blocklist [this = %p]", mSpec.get(), this));
+    return mPendingLookup->OnComplete(
+        nsIApplicationReputationService::VERDICT_DANGEROUS,
+        Reason::LocalBlocklist, NS_OK);
+  }
+
+  nsAutoCString allowList;
+  Preferences::GetCString(PREF_DOWNLOAD_ALLOW_TABLE, allowList);
+  if ((mLookupType != LookupType::BlocklistOnly) &&
+      FindInReadable(allowList, tables)) {
+    mPendingLookup->mAllowlistCount++;
+    Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_LOCAL, ALLOW_LIST);
+    LOG(("Found principal %s on allowlist [this = %p]", mSpec.get(), this));
+    // Don't call onComplete, since blocklisting trumps allowlisting
+    return mPendingLookup->LookupNext();
+  }
+
+  LOG(("Didn't find principal %s on any list [this = %p]", mSpec.get(), this));
+  Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_LOCAL, NO_LIST);
+  return mPendingLookup->LookupNext();
+}
+
+NS_IMPL_ISUPPORTS(PendingLookup, nsIStreamListener, nsIRequestObserver,
+                  nsIObserver, nsISupportsWeakReference, nsITimerCallback,
+                  nsINamed)
+
+PendingLookup::PendingLookup(nsIApplicationReputationQuery* aQuery,
+                             nsIApplicationReputationCallback* aCallback)
+    : mIsBinaryFile(false),
+      mBlocklistCount(0),
+      mAllowlistCount(0),
+      mQuery(aQuery),
+      mCallback(aCallback) {
+  LOG(("Created pending lookup [this = %p]", this));
+}
+
+PendingLookup::~PendingLookup() {
+  LOG(("Destroying pending lookup [this = %p]", this));
+}
+
+static const char* const kDmgFileExtensions[] = {
+    ".cdr",          ".dart",        ".dc42",  ".diskcopy42",
+    ".dmg",          ".dmgpart",     ".dvdr",  ".img",
+    ".imgpart",      ".iso",         ".ndif",  ".smi",
+    ".sparsebundle", ".sparseimage", ".toast", ".udif",
+};
+
+static const char* const kRarFileExtensions[] = {
+    ".r00", ".r01", ".r02", ".r03", ".r04", ".r05", ".r06", ".r07",
+    ".r08", ".r09", ".r10", ".r11", ".r12", ".r13", ".r14", ".r15",
+    ".r16", ".r17", ".r18", ".r19", ".r20", ".r21", ".r22", ".r23",
+    ".r24", ".r25", ".r26", ".r27", ".r28", ".r29", ".rar",
+};
+
+static const char* const kZipFileExtensions[] = {
+    ".zip",   // Generic archive
+    ".zipx",  // WinZip
+};
+
+static const char* GetFileExt(const nsACString& aFilename,
+                              const char* const aFileExtensions[],
+                              const size_t aLength) {
+  for (size_t i = 0; i < aLength; ++i) {
+    if (StringEndsWith(aFilename, nsDependentCString(aFileExtensions[i]))) {
+      return aFileExtensions[i];
+    }
+  }
+  return nullptr;
+}
+
+static const char* GetFileExt(const nsACString& aFilename) {
+#define _GetFileExt(_f, _l) GetFileExt(_f, _l, ArrayLength(_l))
+  const char* ext = _GetFileExt(
+      aFilename, ApplicationReputationService::kBinaryFileExtensions);
+  if (ext == nullptr &&
+      !_GetFileExt(aFilename,
+                   ApplicationReputationService::kNonBinaryExecutables)) {
+    ext = _GetFileExt(aFilename, sExecutableExts);
+  }
+  return ext;
+}
+
+// Returns true if the file extension matches one in the given array.
+static bool IsFileType(const nsACString& aFilename,
+                       const char* const aFileExtensions[],
+                       const size_t aLength) {
+  return GetFileExt(aFilename, aFileExtensions, aLength) != nullptr;
+}
+
+static bool IsBinary(const nsACString& aFilename) {
+  return IsFileType(aFilename,
+                    ApplicationReputationService::kBinaryFileExtensions,
+                    ArrayLength(
+                        ApplicationReputationService::kBinaryFileExtensions)) ||
+         (!IsFileType(
+              aFilename, ApplicationReputationService::kNonBinaryExecutables,
+              ArrayLength(
+                  ApplicationReputationService::kNonBinaryExecutables)) &&
+          IsFileType(aFilename, sExecutableExts, ArrayLength(sExecutableExts)));
+}
+
+ClientDownloadRequest::DownloadType PendingLookup::GetDownloadType(
+    const nsACString& aFilename) {
+  MOZ_ASSERT(IsBinary(aFilename));
+
+  // From
+  // https://cs.chromium.org/chromium/src/chrome/common/safe_browsing/download_protection_util.cc?l=17
+  if (StringEndsWith(aFilename, ".zip"_ns)) {
+    return ClientDownloadRequest::ZIPPED_EXECUTABLE;
+  } else if (StringEndsWith(aFilename, ".apk"_ns)) {
+    return ClientDownloadRequest::ANDROID_APK;
+  } else if (StringEndsWith(aFilename, ".app"_ns) ||
+             StringEndsWith(aFilename, ".applescript"_ns) ||
+             StringEndsWith(aFilename, ".cdr"_ns) ||
+             StringEndsWith(aFilename, ".dart"_ns) ||
+             StringEndsWith(aFilename, ".dc42"_ns) ||
+             StringEndsWith(aFilename, ".diskcopy42"_ns) ||
+             StringEndsWith(aFilename, ".dmg"_ns) ||
+             StringEndsWith(aFilename, ".dmgpart"_ns) ||
+             StringEndsWith(aFilename, ".dvdr"_ns) ||
+             StringEndsWith(aFilename, ".img"_ns) ||
+             StringEndsWith(aFilename, ".imgpart"_ns) ||
+             StringEndsWith(aFilename, ".iso"_ns) ||
+             StringEndsWith(aFilename, ".mpkg"_ns) ||
+             StringEndsWith(aFilename, ".ndif"_ns) ||
+             StringEndsWith(aFilename, ".osas"_ns) ||
+             StringEndsWith(aFilename, ".osax"_ns) ||
+             StringEndsWith(aFilename, ".pkg"_ns) ||
+             StringEndsWith(aFilename, ".scpt"_ns) ||
+             StringEndsWith(aFilename, ".scptd"_ns) ||
+             StringEndsWith(aFilename, ".seplugin"_ns) ||
+             StringEndsWith(aFilename, ".smi"_ns) ||
+             StringEndsWith(aFilename, ".sparsebundle"_ns) ||
+             StringEndsWith(aFilename, ".sparseimage"_ns) ||
+             StringEndsWith(aFilename, ".toast"_ns) ||
+             StringEndsWith(aFilename, ".udif"_ns)) {
+    return ClientDownloadRequest::MAC_EXECUTABLE;
+  }
+
+  return ClientDownloadRequest::WIN_EXECUTABLE;  // default to Windows binaries
+}
+
+nsresult PendingLookup::LookupNext() {
+  // We must call LookupNext or SendRemoteQuery upon return.
+  // Look up all of the URLs that could allow or block this download.
+  // Blocklist first.
+
+  // If a url is in blocklist we should call PendingLookup::OnComplete directly.
+  MOZ_ASSERT(mBlocklistCount == 0);
+
+  nsCString spec;
+  if (!mAnylistSpecs.IsEmpty()) {
+    // Check the source URI only.
+    spec = mAnylistSpecs.PopLastElement();
+    RefPtr<PendingDBLookup> lookup(new PendingDBLookup(this));
+
+    // We don't need to check whitelist if the file is not a binary file.
+    auto type =
+        mIsBinaryFile ? LookupType::BothLists : LookupType::BlocklistOnly;
+    return lookup->LookupSpec(spec, type);
+  }
+
+  if (!mBlocklistSpecs.IsEmpty()) {
+    // Check the referrer and redirect chain.
+    spec = mBlocklistSpecs.PopLastElement();
+    RefPtr<PendingDBLookup> lookup(new PendingDBLookup(this));
+    return lookup->LookupSpec(spec, LookupType::BlocklistOnly);
+  }
+
+  // Now that we've looked up all of the URIs against the blocklist,
+  // if any of mAnylistSpecs or mAllowlistSpecs matched the allowlist,
+  // go ahead and pass.
+  if (mAllowlistCount > 0) {
+    return OnComplete(nsIApplicationReputationService::VERDICT_SAFE,
+                      Reason::LocalWhitelist, NS_OK);
+  }
+
+  MOZ_ASSERT_IF(!mIsBinaryFile, mAllowlistSpecs.Length() == 0);
+
+  // Only binary signatures remain.
+  if (!mAllowlistSpecs.IsEmpty()) {
+    spec = mAllowlistSpecs.PopLastElement();
+    LOG(("PendingLookup::LookupNext: checking %s on allowlist", spec.get()));
+    RefPtr<PendingDBLookup> lookup(new PendingDBLookup(this));
+    return lookup->LookupSpec(spec, LookupType::AllowlistOnly);
+  }
+
+  if (!mFileName.IsEmpty()) {
+    if (IsBinary(mFileName)) {
+      AccumulateCategorical(
+          mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_BINARY_TYPE::
+              BinaryFile);
+    } else if (IsFileType(mFileName, kSafeFileExtensions,
+                          ArrayLength(kSafeFileExtensions))) {
+      AccumulateCategorical(
+          mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_BINARY_TYPE::
+              NonBinaryFile);
+    } else if (IsFileType(mFileName, kMozNonBinaryExecutables,
+                          ArrayLength(kMozNonBinaryExecutables))) {
+      AccumulateCategorical(
+          mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_BINARY_TYPE::
+              MozNonBinaryFile);
+    } else {
+      AccumulateCategorical(
+          mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_BINARY_TYPE::
+              UnknownFile);
+    }
+  } else {
+    AccumulateCategorical(
+        mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_BINARY_TYPE::
+            MissingFilename);
+  }
+
+  if (IsFileType(mFileName, kDmgFileExtensions,
+                 ArrayLength(kDmgFileExtensions))) {
+    AccumulateCategorical(
+        mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_BINARY_ARCHIVE::
+            DmgFile);
+  } else if (IsFileType(mFileName, kRarFileExtensions,
+                        ArrayLength(kRarFileExtensions))) {
+    AccumulateCategorical(
+        mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_BINARY_ARCHIVE::
+            RarFile);
+  } else if (IsFileType(mFileName, kZipFileExtensions,
+                        ArrayLength(kZipFileExtensions))) {
+    AccumulateCategorical(
+        mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_BINARY_ARCHIVE::
+            ZipFile);
+  } else if (mIsBinaryFile) {
+    AccumulateCategorical(
+        mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_BINARY_ARCHIVE::
+            OtherBinaryFile);
+  }
+
+  // There are no more URIs to check against local list. If the file is
+  // not eligible for remote lookup, bail.
+  if (!mIsBinaryFile) {
+    LOG(("Not eligible for remote lookups [this=%p]", this));
+    return OnComplete(nsIApplicationReputationService::VERDICT_SAFE,
+                      Reason::NonBinaryFile, NS_OK);
+  }
+
+  nsresult rv = SendRemoteQuery();
+  if (NS_FAILED(rv)) {
+    return OnComplete(nsIApplicationReputationService::VERDICT_SAFE,
+                      Reason::InternalError, rv);
+  }
+  return NS_OK;
+}
+
+nsCString PendingLookup::EscapeCertificateAttribute(
+    const nsACString& aAttribute) {
+  // Escape '/' because it's a field separator, and '%' because Chrome does
+  nsCString escaped;
+  escaped.SetCapacity(aAttribute.Length());
+  for (unsigned int i = 0; i < aAttribute.Length(); ++i) {
+    if (aAttribute.Data()[i] == '%') {
+      escaped.AppendLiteral("%25");
+    } else if (aAttribute.Data()[i] == '/') {
+      escaped.AppendLiteral("%2F");
+    } else if (aAttribute.Data()[i] == ' ') {
+      escaped.AppendLiteral("%20");
+    } else {
+      escaped.Append(aAttribute.Data()[i]);
+    }
+  }
+  return escaped;
+}
+
+nsCString PendingLookup::EscapeFingerprint(const nsACString& aFingerprint) {
+  // Google's fingerprint doesn't have colons
+  nsCString escaped;
+  escaped.SetCapacity(aFingerprint.Length());
+  for (unsigned int i = 0; i < aFingerprint.Length(); ++i) {
+    if (aFingerprint.Data()[i] != ':') {
+      escaped.Append(aFingerprint.Data()[i]);
+    }
+  }
+  return escaped;
+}
+
+nsresult PendingLookup::GenerateWhitelistStringsForPair(
+    nsIX509Cert* certificate, nsIX509Cert* issuer) {
+  // The whitelist paths have format:
+  // http://sb-ssl.google.com/safebrowsing/csd/certificate/<issuer_cert_fingerprint>[/CN=<cn>][/O=<org>][/OU=<unit>]
+  // Any of CN, O, or OU may be omitted from the whitelist entry. Unfortunately
+  // this is not publicly documented, but the Chrome implementation can be found
+  // here:
+  // https://code.google.com/p/chromium/codesearch#search/&q=GetCertificateWhitelistStrings
+  nsCString whitelistString(
+      "http://sb-ssl.google.com/safebrowsing/csd/certificate/");
+
+  nsString fingerprint;
+  nsresult rv = issuer->GetSha1Fingerprint(fingerprint);
+  NS_ENSURE_SUCCESS(rv, rv);
+  whitelistString.Append(EscapeFingerprint(NS_ConvertUTF16toUTF8(fingerprint)));
+
+  nsString commonName;
+  rv = certificate->GetCommonName(commonName);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!commonName.IsEmpty()) {
+    whitelistString.AppendLiteral("/CN=");
+    whitelistString.Append(
+        EscapeCertificateAttribute(NS_ConvertUTF16toUTF8(commonName)));
+  }
+
+  nsString organization;
+  rv = certificate->GetOrganization(organization);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!organization.IsEmpty()) {
+    whitelistString.AppendLiteral("/O=");
+    whitelistString.Append(
+        EscapeCertificateAttribute(NS_ConvertUTF16toUTF8(organization)));
+  }
+
+  nsString organizationalUnit;
+  rv = certificate->GetOrganizationalUnit(organizationalUnit);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!organizationalUnit.IsEmpty()) {
+    whitelistString.AppendLiteral("/OU=");
+    whitelistString.Append(
+        EscapeCertificateAttribute(NS_ConvertUTF16toUTF8(organizationalUnit)));
+  }
+  LOG(("Whitelisting %s", whitelistString.get()));
+
+  mAllowlistSpecs.AppendElement(whitelistString);
+  return NS_OK;
+}
+
+nsresult PendingLookup::GenerateWhitelistStringsForChain(
+    const safe_browsing::ClientDownloadRequest_CertificateChain& aChain) {
+  // We need a signing certificate and an issuer to construct a whitelist
+  // entry.
+  if (aChain.element_size() < 2) {
+    return NS_OK;
+  }
+
+  // Get the signer.
+  nsresult rv;
+  nsCOMPtr<nsIX509CertDB> certDB = do_GetService(NS_X509CERTDB_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIX509Cert> signer;
+  nsTArray<uint8_t> signerBytes;
+  signerBytes.AppendElements(aChain.element(0).certificate().data(),
+                             aChain.element(0).certificate().size());
+  rv = certDB->ConstructX509(signerBytes, getter_AddRefs(signer));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (int i = 1; i < aChain.element_size(); ++i) {
+    // Get the issuer.
+    nsCOMPtr<nsIX509Cert> issuer;
+    nsTArray<uint8_t> issuerBytes;
+    issuerBytes.AppendElements(aChain.element(i).certificate().data(),
+                               aChain.element(i).certificate().size());
+    rv = certDB->ConstructX509(issuerBytes, getter_AddRefs(issuer));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = GenerateWhitelistStringsForPair(signer, issuer);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return NS_OK;
+}
+
+nsresult PendingLookup::GenerateWhitelistStrings() {
+  for (int i = 0; i < mRequest.signature().certificate_chain_size(); ++i) {
+    nsresult rv = GenerateWhitelistStringsForChain(
+        mRequest.signature().certificate_chain(i));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return NS_OK;
+}
+
+nsresult PendingLookup::AddRedirects(nsIArray* aRedirects) {
+  uint32_t length = 0;
+  aRedirects->GetLength(&length);
+  LOG(("ApplicationReputation: Got %u redirects", length));
+  nsCOMPtr<nsISimpleEnumerator> iter;
+  nsresult rv = aRedirects->Enumerate(getter_AddRefs(iter));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool hasMoreRedirects = false;
+  rv = iter->HasMoreElements(&hasMoreRedirects);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  while (hasMoreRedirects) {
+    nsCOMPtr<nsISupports> supports;
+    rv = iter->GetNext(getter_AddRefs(supports));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIRedirectHistoryEntry> redirectEntry =
+        do_QueryInterface(supports, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIPrincipal> principal;
+    rv = redirectEntry->GetPrincipal(getter_AddRefs(principal));
+    auto* basePrin = BasePrincipal::Cast(principal);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIURI> uri;
+    rv = basePrin->GetURI(getter_AddRefs(uri));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Add the spec to our list of local lookups. The most recent redirect is
+    // the last element.
+    nsCString spec;
+    rv = GetStrippedSpec(uri, spec);
+    NS_ENSURE_SUCCESS(rv, rv);
+    mBlocklistSpecs.AppendElement(spec);
+    LOG(("ApplicationReputation: Appending redirect %s\n", spec.get()));
+
+    // Store the redirect information in the remote request.
+    ClientDownloadRequest_Resource* resource = mRequest.add_resources();
+    resource->set_url(spec.get());
+    resource->set_type(ClientDownloadRequest::DOWNLOAD_REDIRECT);
+
+    rv = iter->HasMoreElements(&hasMoreRedirects);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return NS_OK;
+}
+
+nsresult PendingLookup::StartLookup() {
+  mStartTime = TimeStamp::Now();
+  nsresult rv = DoLookupInternal();
+  if (NS_FAILED(rv)) {
+    return OnComplete(nsIApplicationReputationService::VERDICT_SAFE,
+                      Reason::InternalError, NS_OK);
+  }
+  return rv;
+}
+
+nsresult PendingLookup::GetSpecHash(nsACString& aSpec,
+                                    nsACString& hexEncodedHash) {
+  nsCOMPtr<nsICryptoHash> cryptoHash;
+  nsresult rv =
+      NS_NewCryptoHash(nsICryptoHash::SHA256, getter_AddRefs(cryptoHash));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = cryptoHash->Update(
+      reinterpret_cast<const uint8_t*>(aSpec.BeginReading()), aSpec.Length());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString binaryHash;
+  rv = cryptoHash->Finish(false, binaryHash);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // This needs to match HexEncode() in Chrome's
+  // src/base/strings/string_number_conversions.cc
+  static const char* const hex = "0123456789ABCDEF";
+  hexEncodedHash.SetCapacity(2 * binaryHash.Length());
+  for (size_t i = 0; i < binaryHash.Length(); ++i) {
+    auto c = static_cast<unsigned char>(binaryHash[i]);
+    hexEncodedHash.Append(hex[(c >> 4) & 0x0F]);
+    hexEncodedHash.Append(hex[c & 0x0F]);
+  }
+
+  return NS_OK;
+}
+
+nsresult PendingLookup::GetStrippedSpec(nsIURI* aUri, nsACString& escaped) {
+  if (NS_WARN_IF(!aUri)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  nsresult rv;
+  rv = aUri->GetScheme(escaped);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (escaped.EqualsLiteral("blob")) {
+    aUri->GetSpec(escaped);
+    LOG(
+        ("PendingLookup::GetStrippedSpec(): blob URL left unstripped as '%s' "
+         "[this = %p]",
+         PromiseFlatCString(escaped).get(), this));
+    return NS_OK;
+  }
+
+  if (escaped.EqualsLiteral("data")) {
+    // Replace URI with "data:<everything before comma>,SHA256(<whole URI>)"
+    aUri->GetSpec(escaped);
+    int32_t comma = escaped.FindChar(',');
+    if (comma > -1 &&
+        static_cast<nsCString::size_type>(comma) < escaped.Length() - 1) {
+      MOZ_ASSERT(comma > 4, "Data URIs start with 'data:'");
+      nsAutoCString hexEncodedHash;
+      rv = GetSpecHash(escaped, hexEncodedHash);
+      if (NS_SUCCEEDED(rv)) {
+        escaped.Truncate(comma + 1);
+        escaped.Append(hexEncodedHash);
+      }
+    }
+
+    LOG(
+        ("PendingLookup::GetStrippedSpec(): data URL stripped to '%s' [this = "
+         "%p]",
+         PromiseFlatCString(escaped).get(), this));
+    return NS_OK;
+  }
+
+  // If aURI is not an nsIURL, we do not want to check the lists or send a
+  // remote query.
+  nsCOMPtr<nsIURL> url = do_QueryInterface(aUri, &rv);
+  if (NS_FAILED(rv)) {
+    LOG(
+        ("PendingLookup::GetStrippedSpec(): scheme '%s' is not supported [this "
+         "= %p]",
+         PromiseFlatCString(escaped).get(), this));
+    return rv;
+  }
+
+  nsCString temp;
+  rv = url->GetHostPort(temp);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  escaped.AppendLiteral("://");
+  escaped.Append(temp);
+
+  rv = url->GetFilePath(temp);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // nsIUrl.filePath starts with '/'
+  escaped.Append(temp);
+
+  LOG(("PendingLookup::GetStrippedSpec(): URL stripped to '%s' [this = %p]",
+       PromiseFlatCString(escaped).get(), this));
+  return NS_OK;
+}
+
+nsresult PendingLookup::DoLookupInternal() {
+  // We want to check the target URI, its referrer, and associated redirects
+  // against the local lists.
+  nsCOMPtr<nsIURI> uri;
+  nsresult rv = mQuery->GetSourceURI(getter_AddRefs(uri));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString sourceSpec;
+  rv = GetStrippedSpec(uri, sourceSpec);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mAnylistSpecs.AppendElement(sourceSpec);
+
+  ClientDownloadRequest_Resource* resource = mRequest.add_resources();
+  resource->set_url(sourceSpec.get());
+  resource->set_type(ClientDownloadRequest::DOWNLOAD_URL);
+
+  nsCOMPtr<nsIReferrerInfo> referrerInfo;
+  mozilla::Unused << mQuery->GetReferrerInfo(getter_AddRefs(referrerInfo));
+  nsCOMPtr<nsIURI> referrer;
+  // It is quite possible that referrer header is omitted due to security reason
+  // (for example navigation from https-> http). Hence we should use the
+  // original referrer which has not applied referrer policy yet, to make sure
+  // we don't mistakenly allow unsafe download.
+  if (referrerInfo) {
+    referrer = referrerInfo->GetOriginalReferrer();
+  }
+
+  if (referrer) {
+    nsCString referrerSpec;
+    rv = GetStrippedSpec(referrer, referrerSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+    mBlocklistSpecs.AppendElement(referrerSpec);
+    resource->set_referrer(referrerSpec.get());
+  }
+
+  nsCOMPtr<nsIArray> redirects;
+  rv = mQuery->GetRedirects(getter_AddRefs(redirects));
+  if (redirects) {
+    AddRedirects(redirects);
+  } else {
+    LOG(("ApplicationReputation: Got no redirects [this=%p]", this));
+  }
+
+  rv = mQuery->GetSuggestedFileName(mFileName);
+  if (NS_SUCCEEDED(rv) && !mFileName.IsEmpty()) {
+    mIsBinaryFile = IsBinary(mFileName);
+    LOG(("Suggested filename: %s [binary = %d, this = %p]", mFileName.get(),
+         mIsBinaryFile, this));
+  } else {
+    nsAutoCString errorName;
+    mozilla::GetErrorName(rv, errorName);
+    LOG(("No suggested filename [rv = %s, this = %p]", errorName.get(), this));
+    mFileName.Truncate();
+  }
+
+  // We can skip parsing certificate for non-binary files because we only
+  // check local block list for them.
+  if (mIsBinaryFile) {
+    nsTArray<nsTArray<nsTArray<uint8_t>>> sigArray;
+    rv = mQuery->GetSignatureInfo(sigArray);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (!sigArray.IsEmpty()) {
+      rv = ParseCertificates(sigArray);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    rv = GenerateWhitelistStrings();
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Start the call chain.
+  return LookupNext();
+}
+
+nsresult PendingLookup::OnComplete(uint32_t aVerdict, Reason aReason,
+                                   nsresult aRv) {
+  if (NS_FAILED(aRv)) {
+    nsAutoCString errorName;
+    mozilla::GetErrorName(aRv, errorName);
+    LOG(
+        ("Failed sending remote query for application reputation "
+         "[rv = %s, this = %p]",
+         errorName.get(), this));
+  }
+
+  if (mTimeoutTimer) {
+    mTimeoutTimer->Cancel();
+    mTimeoutTimer = nullptr;
+  }
+
+  bool shouldBlock = true;
+  switch (aVerdict) {
+    case nsIApplicationReputationService::VERDICT_DANGEROUS:
+      if (!Preferences::GetBool(PREF_BLOCK_DANGEROUS, true)) {
+        shouldBlock = false;
+        aReason = Reason::DangerousPrefOff;
+      }
+      break;
+    case nsIApplicationReputationService::VERDICT_UNCOMMON:
+      if (!Preferences::GetBool(PREF_BLOCK_UNCOMMON, true)) {
+        shouldBlock = false;
+        aReason = Reason::UncommonPrefOff;
+      }
+      break;
+    case nsIApplicationReputationService::VERDICT_POTENTIALLY_UNWANTED:
+      if (!Preferences::GetBool(PREF_BLOCK_POTENTIALLY_UNWANTED, true)) {
+        shouldBlock = false;
+        aReason = Reason::UnwantedPrefOff;
+      }
+      break;
+    case nsIApplicationReputationService::VERDICT_DANGEROUS_HOST:
+      if (!Preferences::GetBool(PREF_BLOCK_DANGEROUS_HOST, true)) {
+        shouldBlock = false;
+        aReason = Reason::DangerousHostPrefOff;
+      }
+      break;
+    default:
+      shouldBlock = false;
+      break;
+  }
+
+  AccumulateCategorical(aReason);
+  Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SHOULD_BLOCK,
+             shouldBlock);
+
+  double t = (TimeStamp::Now() - mStartTime).ToMilliseconds();
+  LOG(("Application Reputation verdict is %u, obtained in %f ms [this = %p]",
+       aVerdict, t, this));
+  if (shouldBlock) {
+    LOG(("Application Reputation check failed, blocking bad binary [this = %p]",
+         this));
+  } else {
+    LOG(("Application Reputation check passed [this = %p]", this));
+  }
+
+  nsresult res = mCallback->OnComplete(shouldBlock, aRv, aVerdict);
+  return res;
+}
+
+nsresult PendingLookup::ParseCertificates(
+    const nsTArray<nsTArray<nsTArray<uint8_t>>>& aSigArray) {
+  // Binaries may be signed by multiple chains of certificates. If there are no
+  // chains, the binary is unsigned (or we were unable to extract signature
+  // information on a non-Windows platform)
+
+  // Each chain may have multiple certificates.
+  for (const auto& certList : aSigArray) {
+    safe_browsing::ClientDownloadRequest_CertificateChain* certChain =
+        mRequest.mutable_signature()->add_certificate_chain();
+    for (const auto& cert : certList) {
+      // Add this certificate to the protobuf to send remotely.
+      certChain->add_element()->set_certificate(cert.Elements(), cert.Length());
+    }
+  }
+  if (mRequest.signature().certificate_chain_size() > 0) {
+    mRequest.mutable_signature()->set_trusted(true);
+  }
+  return NS_OK;
+}
+
+nsresult PendingLookup::SendRemoteQuery() {
+  MOZ_ASSERT(!IsFileType(
+      mFileName, ApplicationReputationService::kNonBinaryExecutables,
+      ArrayLength(ApplicationReputationService::kNonBinaryExecutables)));
+  Reason reason = Reason::NotSet;
+  nsresult rv = SendRemoteQueryInternal(reason);
+  if (NS_FAILED(rv)) {
+    return OnComplete(nsIApplicationReputationService::VERDICT_SAFE, reason,
+                      rv);
+  }
+  // SendRemoteQueryInternal has fired off the query and we call OnComplete in
+  // the nsIStreamListener.onStopRequest.
+  return rv;
+}
+
+nsresult PendingLookup::SendRemoteQueryInternal(Reason& aReason) {
+  auto scopeExit = mozilla::MakeScopeExit([&aReason]() {
+    if (aReason == Reason::NotSet) {
+      aReason = Reason::InternalError;
+    }
+  });
+
+  // If we aren't supposed to do remote lookups, bail.
+  if (!Preferences::GetBool(PREF_SB_DOWNLOADS_REMOTE_ENABLED, false)) {
+    LOG(("Remote lookups are disabled [this = %p]", this));
+    aReason = Reason::RemoteLookupDisabled;
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  // If the remote lookup URL is empty or absent, bail.
+  nsString serviceUrl;
+  nsCOMPtr<nsIURLFormatter> formatter(
+      do_GetService("@mozilla.org/toolkit/URLFormatterService;1"));
+  if (!formatter ||
+      NS_FAILED(formatter->FormatURLPref(
+          NS_ConvertASCIItoUTF16(PREF_SB_APP_REP_URL), serviceUrl)) ||
+      serviceUrl.IsEmpty() || u"about:blank"_ns.Equals(serviceUrl)) {
+    LOG(("Remote lookup URL is empty or absent [this = %p]", this));
+    aReason = Reason::RemoteLookupDisabled;
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  LOG(("Sending remote query for application reputation [this = %p]", this));
+  // We did not find a local result, so fire off the query to the
+  // application reputation service.
+  nsCOMPtr<nsIURI> uri;
+  nsresult rv;
+  rv = mQuery->GetSourceURI(getter_AddRefs(uri));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCString spec;
+  rv = GetStrippedSpec(uri, spec);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mRequest.set_url(spec.get());
+
+  uint32_t fileSize;
+  rv = mQuery->GetFileSize(&fileSize);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mRequest.set_length(fileSize);
+  // We have no way of knowing whether or not a user initiated the
+  // download. Set it to true to lessen the chance of false positives.
+  mRequest.set_user_initiated(true);
+
+  nsCString locale;
+  rv = LocaleService::GetInstance()->GetAppLocaleAsBCP47(locale);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mRequest.set_locale(locale.get());
+  nsCString sha256Hash;
+  rv = mQuery->GetSha256Hash(sha256Hash);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mRequest.mutable_digests()->set_sha256(
+      std::string(sha256Hash.Data(), sha256Hash.Length()));
+  mRequest.set_file_basename(mFileName.get());
+  mRequest.set_download_type(GetDownloadType(mFileName));
+
+  if (mRequest.signature().trusted()) {
+    LOG(
+        ("Got signed binary for remote application reputation check "
+         "[this = %p]",
+         this));
+  } else {
+    LOG(
+        ("Got unsigned binary for remote application reputation check "
+         "[this = %p]",
+         this));
+  }
+
+  // Serialize the protocol buffer to a string. This can only fail if we are
+  // out of memory, or if the protocol buffer req is missing required fields
+  // (only the URL for now).
+  std::string serialized;
+  if (!mRequest.SerializeToString(&serialized)) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  if (LOG_ENABLED()) {
+    nsAutoCString serializedStr(serialized.c_str(), serialized.length());
+    serializedStr.ReplaceSubstring("\0"_ns, "\\0"_ns);
+
+    LOG(("Serialized protocol buffer [this = %p]: (length=%zd) %s", this,
+         serializedStr.Length(), serializedStr.get()));
+  }
+
+  // Set the input stream to the serialized protocol buffer
+  nsCOMPtr<nsIStringInputStream> sstream =
+      do_CreateInstance("@mozilla.org/io/string-input-stream;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = sstream->SetData(serialized.c_str(), serialized.length());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Set up the channel to transmit the request to the service.
+  nsCOMPtr<nsIIOService> ios = do_GetService(NS_IOSERVICE_CONTRACTID, &rv);
+  rv = ios->NewChannel(NS_ConvertUTF16toUTF8(serviceUrl), nullptr, nullptr,
+                       nullptr,  // aLoadingNode
+                       nsContentUtils::GetSystemPrincipal(),
+                       nullptr,  // aTriggeringPrincipal
+                       nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+                       nsIContentPolicy::TYPE_OTHER, getter_AddRefs(mChannel));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mChannel->SetLoadFlags(nsIChannel::LOAD_BYPASS_URL_CLASSIFIER);
+
+  nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
+  mozilla::OriginAttributes attrs;
+  attrs.mFirstPartyDomain.AssignLiteral(NECKO_SAFEBROWSING_FIRST_PARTY_DOMAIN);
+  loadInfo->SetOriginAttributes(attrs);
+
+  nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(mChannel, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  mozilla::Unused << httpChannel;
+
+  // Upload the protobuf to the application reputation service.
+  nsCOMPtr<nsIUploadChannel2> uploadChannel = do_QueryInterface(mChannel, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = uploadChannel->ExplicitSetUploadStream(
+      sstream, "application/octet-stream"_ns, serialized.size(), "POST"_ns,
+      false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t timeoutMs =
+      Preferences::GetUint(PREF_SB_DOWNLOADS_REMOTE_TIMEOUT, 10000);
+  NS_NewTimerWithCallback(getter_AddRefs(mTimeoutTimer), this, timeoutMs,
+                          nsITimer::TYPE_ONE_SHOT);
+
+  mTelemetryRemoteRequestStartMs = PR_IntervalNow();
+
+  rv = mChannel->AsyncOpen(this);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PendingLookup::Notify(nsITimer* aTimer) {
+  LOG(("Remote lookup timed out [this = %p]", this));
+  MOZ_ASSERT(aTimer == mTimeoutTimer);
+  Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_REMOTE_LOOKUP_TIMEOUT,
+             true);
+  mChannel->Cancel(NS_ERROR_NET_TIMEOUT_EXTERNAL);
+  mTimeoutTimer->Cancel();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PendingLookup::GetName(nsACString& aName) {
+  aName.AssignLiteral("PendingLookup");
+  return NS_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// nsIObserver implementation
+NS_IMETHODIMP
+PendingLookup::Observe(nsISupports* aSubject, const char* aTopic,
+                       const char16_t* aData) {
+  if (!strcmp(aTopic, "quit-application")) {
+    if (mTimeoutTimer) {
+      mTimeoutTimer->Cancel();
+      mTimeoutTimer = nullptr;
+    }
+    if (mChannel) {
+      mChannel->Cancel(NS_ERROR_ABORT);
+    }
+  }
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsIStreamListener
+static nsresult AppendSegmentToString(nsIInputStream* inputStream,
+                                      void* closure, const char* rawSegment,
+                                      uint32_t toOffset, uint32_t count,
+                                      uint32_t* writeCount) {
+  nsAutoCString* decodedData = static_cast<nsAutoCString*>(closure);
+  decodedData->Append(rawSegment, count);
+  *writeCount = count;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PendingLookup::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aStream,
+                               uint64_t offset, uint32_t count) {
+  uint32_t read;
+  return aStream->ReadSegments(AppendSegmentToString, &mResponse, count, &read);
+}
+
+NS_IMETHODIMP
+PendingLookup::OnStartRequest(nsIRequest* aRequest) { return NS_OK; }
+
+NS_IMETHODIMP
+PendingLookup::OnStopRequest(nsIRequest* aRequest, nsresult aResult) {
+  NS_ENSURE_STATE(mCallback);
+
+  if (aResult != NS_ERROR_NET_TIMEOUT_EXTERNAL) {
+    Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_REMOTE_LOOKUP_TIMEOUT,
+               false);
+
+    MOZ_ASSERT(mTelemetryRemoteRequestStartMs > 0);
+    int32_t msecs = PR_IntervalToMilliseconds(PR_IntervalNow() -
+                                              mTelemetryRemoteRequestStartMs);
+
+    MOZ_ASSERT(msecs >= 0);
+    mozilla::Telemetry::Accumulate(
+        mozilla::Telemetry::APPLICATION_REPUTATION_REMOTE_LOOKUP_RESPONSE_TIME,
+        msecs);
+  }
+
+  uint32_t verdict = nsIApplicationReputationService::VERDICT_SAFE;
+  Reason reason = Reason::NotSet;
+  nsresult rv = OnStopRequestInternal(aRequest, aResult, verdict, reason);
+  OnComplete(verdict, reason, rv);
+  return rv;
+}
+
+nsresult PendingLookup::OnStopRequestInternal(nsIRequest* aRequest,
+                                              nsresult aResult,
+                                              uint32_t& aVerdict,
+                                              Reason& aReason) {
+  auto scopeExit = mozilla::MakeScopeExit([&aReason]() {
+    // If |aReason| is not set while exiting, there must be an error.
+    if (aReason == Reason::NotSet) {
+      aReason = Reason::NetworkError;
+    }
+  });
+
+  if (NS_FAILED(aResult)) {
+    Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SERVER,
+               SERVER_RESPONSE_FAILED);
+    AccumulateCategorical(NSErrorToLabel(aResult));
+    return aResult;
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsIHttpChannel> channel = do_QueryInterface(aRequest, &rv);
+  if (NS_FAILED(rv)) {
+    Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SERVER,
+               SERVER_RESPONSE_FAILED);
+    AccumulateCategorical(
+        mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_SERVER_2::
+            FailGetChannel);
+    return rv;
+  }
+
+  uint32_t status = 0;
+  rv = channel->GetResponseStatus(&status);
+  if (NS_FAILED(rv)) {
+    Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SERVER,
+               SERVER_RESPONSE_FAILED);
+    AccumulateCategorical(
+        mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_SERVER_2::
+            FailGetResponse);
+    return rv;
+  }
+
+  if (status != 200) {
+    Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SERVER,
+               SERVER_RESPONSE_FAILED);
+    AccumulateCategorical(HTTPStatusToLabel(status));
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  std::string buf(mResponse.Data(), mResponse.Length());
+  safe_browsing::ClientDownloadResponse response;
+  if (!response.ParseFromString(buf)) {
+    LOG(("Invalid protocol buffer response [this = %p]: %s", this,
+         buf.c_str()));
+    Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SERVER,
+               SERVER_RESPONSE_INVALID);
+    return NS_ERROR_CANNOT_CONVERT_DATA;
+  }
+
+  Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SERVER,
+             SERVER_RESPONSE_VALID);
+  AccumulateCategorical(
+      mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_SERVER_2::
+          ResponseValid);
+
+  // Clamp responses 0-7, we only know about 0-4 for now.
+  Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SERVER_VERDICT,
+             std::min<uint32_t>(response.verdict(), 7));
+  const char* ext = GetFileExt(mFileName);
+  AccumulateCategoricalKeyed(nsCString(ext), VerdictToLabel(std::min<uint32_t>(
+                                                 response.verdict(), 7)));
+  switch (response.verdict()) {
+    case safe_browsing::ClientDownloadResponse::DANGEROUS:
+      aVerdict = nsIApplicationReputationService::VERDICT_DANGEROUS;
+      aReason = Reason::VerdictDangerous;
+      break;
+    case safe_browsing::ClientDownloadResponse::DANGEROUS_HOST:
+      aVerdict = nsIApplicationReputationService::VERDICT_DANGEROUS_HOST;
+      aReason = Reason::VerdictDangerousHost;
+      break;
+    case safe_browsing::ClientDownloadResponse::POTENTIALLY_UNWANTED:
+      aVerdict = nsIApplicationReputationService::VERDICT_POTENTIALLY_UNWANTED;
+      aReason = Reason::VerdictUnwanted;
+      break;
+    case safe_browsing::ClientDownloadResponse::UNCOMMON:
+      aVerdict = nsIApplicationReputationService::VERDICT_UNCOMMON;
+      aReason = Reason::VerdictUncommon;
+      break;
+    case safe_browsing::ClientDownloadResponse::UNKNOWN:
+      aVerdict = nsIApplicationReputationService::VERDICT_SAFE;
+      aReason = Reason::VerdictUnknown;
+      break;
+    case safe_browsing::ClientDownloadResponse::SAFE:
+      aVerdict = nsIApplicationReputationService::VERDICT_SAFE;
+      aReason = Reason::VerdictSafe;
+      break;
+    default:
+      // Treat everything else as safe
+      aVerdict = nsIApplicationReputationService::VERDICT_SAFE;
+      aReason = Reason::VerdictUnrecognized;
+      break;
+  }
+
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(ApplicationReputationService, nsIApplicationReputationService)
+
+ApplicationReputationService*
+    ApplicationReputationService::gApplicationReputationService = nullptr;
+
+already_AddRefed<ApplicationReputationService>
+ApplicationReputationService::GetSingleton() {
+  if (!gApplicationReputationService) {
+    // Note: This is cleared in the new ApplicationReputationService destructor.
+    gApplicationReputationService = new ApplicationReputationService();
+  }
+  return do_AddRef(gApplicationReputationService);
+}
+
+ApplicationReputationService::ApplicationReputationService() {
+  LOG(("Application reputation service started up"));
+}
+
+ApplicationReputationService::~ApplicationReputationService() {
+  LOG(("Application reputation service shutting down"));
+  MOZ_ASSERT(gApplicationReputationService == this);
+  gApplicationReputationService = nullptr;
+}
+
+NS_IMETHODIMP
+ApplicationReputationService::QueryReputation(
+    nsIApplicationReputationQuery* aQuery,
+    nsIApplicationReputationCallback* aCallback) {
+  LOG(("Starting application reputation check [query=%p]", aQuery));
+  NS_ENSURE_ARG_POINTER(aQuery);
+  NS_ENSURE_ARG_POINTER(aCallback);
+
+  nsresult rv = QueryReputationInternal(aQuery, aCallback);
+  if (NS_FAILED(rv)) {
+    Reason reason = rv == NS_ERROR_NOT_AVAILABLE ? Reason::DPDisabled
+                                                 : Reason::InternalError;
+
+    AccumulateCategorical(reason);
+    Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SHOULD_BLOCK, false);
+
+    aCallback->OnComplete(false, rv,
+                          nsIApplicationReputationService::VERDICT_SAFE);
+  }
+  return NS_OK;
+}
+
+nsresult ApplicationReputationService::QueryReputationInternal(
+    nsIApplicationReputationQuery* aQuery,
+    nsIApplicationReputationCallback* aCallback) {
+  // If malware checks aren't enabled, don't query application reputation.
+  if (!Preferences::GetBool(PREF_SB_MALWARE_ENABLED, false)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  if (!Preferences::GetBool(PREF_SB_DOWNLOADS_ENABLED, false)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsCOMPtr<nsIURI> uri;
+  nsresult rv = aQuery->GetSourceURI(getter_AddRefs(uri));
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Bail if the URI hasn't been set.
+  NS_ENSURE_STATE(uri);
+
+  // Create a new pending lookup and start the call chain.
+  RefPtr<PendingLookup> lookup(new PendingLookup(aQuery, aCallback));
+
+  // Add an observer for shutdown
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+  if (!observerService) {
+    return NS_ERROR_FAILURE;
+  }
+
+  observerService->AddObserver(lookup, "quit-application", true);
+  return lookup->StartLookup();
+}
+
+nsresult ApplicationReputationService::IsBinary(const nsACString& aFileName,
+                                                bool* aBinary) {
+  *aBinary = ::IsBinary(aFileName);
+  return NS_OK;
+}
+
+nsresult ApplicationReputationService::IsExecutable(const nsACString& aFileName,
+                                                    bool* aExecutable) {
+  *aExecutable =
+      ::IsFileType(aFileName, sExecutableExts, ArrayLength(sExecutableExts));
+  return NS_OK;
+}
diff --git a/toolkit/components/reputationservice/ApplicationReputation.h b/toolkit/components/reputationservice/ApplicationReputation.h
new file mode 100644
index 0000000000..f708c6eb71
--- /dev/null
+++ b/toolkit/components/reputationservice/ApplicationReputation.h
@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef ApplicationReputation_h__
+#define ApplicationReputation_h__
+
+#include "nsIApplicationReputation.h"
+#include "nsISupports.h"
+
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include "mozilla/Logging.h"
+
+class nsIRequest;
+class PendingDBLookup;
+class PendingLookup;
+
+class ApplicationReputationService final
+    : public nsIApplicationReputationService {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIAPPLICATIONREPUTATIONSERVICE
+
+ public:
+  static const char* const kNonBinaryExecutables[5];
+#ifdef XP_WIN
+  static const char* const kBinaryFileExtensions[185];
+#else
+  static const char* const kBinaryFileExtensions[184];
+#endif
+
+  static already_AddRefed<ApplicationReputationService> GetSingleton();
+
+ private:
+  friend class PendingLookup;
+  friend class PendingDBLookup;
+  /**
+   * Global singleton object for holding this factory service.
+   */
+  static ApplicationReputationService* gApplicationReputationService;
+  /**
+   * MOZ_LOG=ApplicationReputation:5
+   */
+  static mozilla::LazyLogModule prlog;
+  /**
+   * This is a singleton, so disallow construction.
+   */
+  ApplicationReputationService();
+  ~ApplicationReputationService();
+  /**
+   * Wrapper function for QueryReputation that makes it easier to ensure the
+   * callback is called.
+   */
+  nsresult QueryReputationInternal(nsIApplicationReputationQuery* aQuery,
+                                   nsIApplicationReputationCallback* aCallback);
+};
+#endif /* ApplicationReputation_h__ */
diff --git a/toolkit/components/reputationservice/ApplicationReputationTelemetryUtils.cpp b/toolkit/components/reputationservice/ApplicationReputationTelemetryUtils.cpp
new file mode 100644
index 0000000000..8487e866c5
--- /dev/null
+++ b/toolkit/components/reputationservice/ApplicationReputationTelemetryUtils.cpp
@@ -0,0 +1,195 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "ApplicationReputationTelemetryUtils.h"
+#include "mozilla/Assertions.h"
+#include "chrome/common/safe_browsing/csd.pb.h"
+
+using ServerLabel = mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_SERVER_2;
+using ServerVerdictLabel =
+    mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_SERVER_VERDICT_2;
+
+struct NSErrorTelemetryResult {
+  nsresult mValue;
+  ServerLabel mLabel;
+};
+
+static const NSErrorTelemetryResult sResult[] = {
+    {
+        NS_ERROR_ALREADY_CONNECTED,
+        ServerLabel::ErrAlreadyConnected,
+    },
+    {
+        NS_ERROR_NOT_CONNECTED,
+        ServerLabel::ErrNotConnected,
+    },
+    {
+        NS_ERROR_CONNECTION_REFUSED,
+        ServerLabel::ErrConnectionRefused,
+    },
+    {
+        NS_ERROR_NET_TIMEOUT,
+        ServerLabel::ErrNetTimeout,
+    },
+    {
+        NS_ERROR_OFFLINE,
+        ServerLabel::ErrOffline,
+    },
+    {
+        NS_ERROR_PORT_ACCESS_NOT_ALLOWED,
+        ServerLabel::ErrPortAccess,
+    },
+    {
+        NS_ERROR_NET_RESET,
+        ServerLabel::ErrNetReset,
+    },
+    {
+        NS_ERROR_NET_INTERRUPT,
+        ServerLabel::ErrNetInterrupt,
+    },
+    {
+        NS_ERROR_PROXY_CONNECTION_REFUSED,
+        ServerLabel::ErrProxyConnection,
+    },
+    {
+        NS_ERROR_NET_PARTIAL_TRANSFER,
+        ServerLabel::ErrNetPartial,
+    },
+    {
+        NS_ERROR_NET_INADEQUATE_SECURITY,
+        ServerLabel::ErrNetInadequate,
+    },
+    {
+        NS_ERROR_UNKNOWN_HOST,
+        ServerLabel::ErrUnknownHost,
+    },
+    {
+        NS_ERROR_DNS_LOOKUP_QUEUE_FULL,
+        ServerLabel::ErrDNSLookupQueue,
+    },
+    {
+        NS_ERROR_UNKNOWN_PROXY_HOST,
+        ServerLabel::ErrUnknownProxyHost,
+    },
+};
+
+mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_SERVER_2 NSErrorToLabel(
+    nsresult aRv) {
+  MOZ_ASSERT(aRv != NS_OK);
+
+  for (const auto& p : sResult) {
+    if (p.mValue == aRv) {
+      return p.mLabel;
+    }
+  }
+  return ServerLabel::ErrOthers;
+}
+
+mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_SERVER_2 HTTPStatusToLabel(
+    uint32_t aStatus) {
+  MOZ_ASSERT(aStatus != 200);
+
+  switch (aStatus) {
+    case 100:
+    case 101:
+      // Unexpected 1xx return code
+      return ServerLabel::HTTP1xx;
+    case 201:
+    case 202:
+    case 203:
+    case 205:
+    case 206:
+      // Unexpected 2xx return code
+      return ServerLabel::HTTP2xx;
+    case 204:
+      // No Content
+      return ServerLabel::HTTP204;
+    case 300:
+    case 301:
+    case 302:
+    case 303:
+    case 304:
+    case 305:
+    case 307:
+    case 308:
+      // Unexpected 3xx return code
+      return ServerLabel::HTTP3xx;
+    case 400:
+      // Bad Request - The HTTP request was not correctly formed.
+      // The client did not provide all required CGI parameters.
+      return ServerLabel::HTTP400;
+    case 401:
+    case 402:
+    case 405:
+    case 406:
+    case 407:
+    case 409:
+    case 410:
+    case 411:
+    case 412:
+    case 414:
+    case 415:
+    case 416:
+    case 417:
+    case 421:
+    case 426:
+    case 428:
+    case 429:
+    case 431:
+    case 451:
+      // Unexpected 4xx return code
+      return ServerLabel::HTTP4xx;
+    case 403:
+      // Forbidden - The client id is invalid.
+      return ServerLabel::HTTP403;
+    case 404:
+      // Not Found
+      return ServerLabel::HTTP404;
+    case 408:
+      // Request Timeout
+      return ServerLabel::HTTP408;
+    case 413:
+      // Request Entity Too Large
+      return ServerLabel::HTTP413;
+    case 500:
+    case 501:
+    case 510:
+      // Unexpected 5xx return code
+      return ServerLabel::HTTP5xx;
+    case 502:
+    case 504:
+    case 511:
+      // Local network errors, we'll ignore these.
+      return ServerLabel::HTTP502_504_511;
+    case 503:
+      // Service Unavailable - The server cannot handle the request.
+      // Clients MUST follow the backoff behavior specified in the
+      // Request Frequency section.
+      return ServerLabel::HTTP503;
+    case 505:
+      // HTTP Version Not Supported - The server CANNOT handle the requested
+      // protocol major version.
+      return ServerLabel::HTTP505;
+    default:
+      return ServerLabel::HTTPOthers;
+  }
+}
+
+mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_SERVER_VERDICT_2
+VerdictToLabel(uint32_t aVerdict) {
+  switch (aVerdict) {
+    case safe_browsing::ClientDownloadResponse::DANGEROUS:
+      return ServerVerdictLabel::Dangerous;
+    case safe_browsing::ClientDownloadResponse::DANGEROUS_HOST:
+      return ServerVerdictLabel::DangerousHost;
+    case safe_browsing::ClientDownloadResponse::POTENTIALLY_UNWANTED:
+      return ServerVerdictLabel::PotentiallyUnwanted;
+    case safe_browsing::ClientDownloadResponse::UNCOMMON:
+      return ServerVerdictLabel::Uncommon;
+    case safe_browsing::ClientDownloadResponse::UNKNOWN:
+      return ServerVerdictLabel::Unknown;
+    default:
+      return ServerVerdictLabel::Safe;
+  }
+}
diff --git a/toolkit/components/reputationservice/ApplicationReputationTelemetryUtils.h b/toolkit/components/reputationservice/ApplicationReputationTelemetryUtils.h
new file mode 100644
index 0000000000..b21c1a3072
--- /dev/null
+++ b/toolkit/components/reputationservice/ApplicationReputationTelemetryUtils.h
@@ -0,0 +1,45 @@
+//* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef ApplicationReputationTelemetryUtils_h__
+#define ApplicationReputationTelemetryUtils_h__
+
+#include "mozilla/Telemetry.h"
+
+/**
+ * Convert network errors to telemetry labels
+ * Only the following nsresults are converted, otherwise this function
+ * will return "ErrorOthers".
+ * NS_ERROR_ALREADY_CONNECTED
+ * NS_ERROR_NOT_CONNECTED
+ * NS_ERROR_CONNECTION_REFUSED
+ * NS_ERROR_NET_TIMEOUT
+ * NS_ERROR_OFFLINE
+ * NS_ERROR_PORT_ACCESS_NOT_ALLOWED
+ * NS_ERROR_NET_RESET
+ * NS_ERROR_NET_INTERRUPT
+ * NS_ERROR_PROXY_CONNECTION_REFUSED
+ * NS_ERROR_NET_PARTIAL_TRANSFER
+ * NS_ERROR_NET_INADEQUATE_SECURITY
+ * NS_ERROR_UNKNOWN_HOST
+ * NS_ERROR_DNS_LOOKUP_QUEUE_FULL
+ * NS_ERROR_UNKNOWN_PROXY_HOST
+ */
+mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_SERVER_2 NSErrorToLabel(
+    nsresult aRv);
+
+/**
+ * Convert http response status to telemetry labels
+ */
+mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_SERVER_2 HTTPStatusToLabel(
+    uint32_t aStatus);
+
+/**
+ * Convert verdict type to telemetry labels
+ */
+mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_SERVER_VERDICT_2
+VerdictToLabel(uint32_t aVerdict);
+
+#endif  // ApplicationReputationTelemetryUtils_h__
diff --git a/toolkit/components/reputationservice/chromium/LICENSE b/toolkit/components/reputationservice/chromium/LICENSE
new file mode 100644
index 0000000000..a32e00ce6b
--- /dev/null
+++ b/toolkit/components/reputationservice/chromium/LICENSE
@@ -0,0 +1,27 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.pb.cc b/toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.pb.cc
new file mode 100644
index 0000000000..a01708ec32
--- /dev/null
+++ b/toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.pb.cc
@@ -0,0 +1,26989 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: csd.proto
+
+#include "csd.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+
+namespace _pb = ::PROTOBUF_NAMESPACE_ID;
+namespace _pbi = _pb::internal;
+
+namespace safe_browsing {
+PROTOBUF_CONSTEXPR ChromeUserPopulation::ChromeUserPopulation(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.finch_active_groups_)*/{}
+  , /*decltype(_impl_.user_population_)*/0
+  , /*decltype(_impl_.is_history_sync_enabled_)*/false} {}
+struct ChromeUserPopulationDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ChromeUserPopulationDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ChromeUserPopulationDefaultTypeInternal() {}
+  union {
+    ChromeUserPopulation _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromeUserPopulationDefaultTypeInternal _ChromeUserPopulation_default_instance_;
+PROTOBUF_CONSTEXPR ClientPhishingRequest_Feature::ClientPhishingRequest_Feature(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.value_)*/0} {}
+struct ClientPhishingRequest_FeatureDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientPhishingRequest_FeatureDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientPhishingRequest_FeatureDefaultTypeInternal() {}
+  union {
+    ClientPhishingRequest_Feature _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPhishingRequest_FeatureDefaultTypeInternal _ClientPhishingRequest_Feature_default_instance_;
+PROTOBUF_CONSTEXPR ClientPhishingRequest::ClientPhishingRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.feature_map_)*/{}
+  , /*decltype(_impl_.non_model_feature_map_)*/{}
+  , /*decltype(_impl_.shingle_hashes_)*/{}
+  , /*decltype(_impl_._shingle_hashes_cached_byte_size_)*/{0}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.obsolete_referrer_url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.obsolete_hash_prefix_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.model_filename_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.population_)*/nullptr
+  , /*decltype(_impl_.client_score_)*/0
+  , /*decltype(_impl_.is_phishing_)*/false
+  , /*decltype(_impl_.model_version_)*/0} {}
+struct ClientPhishingRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientPhishingRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientPhishingRequestDefaultTypeInternal() {}
+  union {
+    ClientPhishingRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPhishingRequestDefaultTypeInternal _ClientPhishingRequest_default_instance_;
+PROTOBUF_CONSTEXPR ClientPhishingResponse::ClientPhishingResponse(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.obsolete_whitelist_expression_)*/{}
+  , /*decltype(_impl_.phishy_)*/false} {}
+struct ClientPhishingResponseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientPhishingResponseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientPhishingResponseDefaultTypeInternal() {}
+  union {
+    ClientPhishingResponse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientPhishingResponseDefaultTypeInternal _ClientPhishingResponse_default_instance_;
+PROTOBUF_CONSTEXPR ClientMalwareRequest_UrlInfo::ClientMalwareRequest_UrlInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.ip_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.method_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.referrer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.resource_type_)*/0} {}
+struct ClientMalwareRequest_UrlInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientMalwareRequest_UrlInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientMalwareRequest_UrlInfoDefaultTypeInternal() {}
+  union {
+    ClientMalwareRequest_UrlInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientMalwareRequest_UrlInfoDefaultTypeInternal _ClientMalwareRequest_UrlInfo_default_instance_;
+PROTOBUF_CONSTEXPR ClientMalwareRequest::ClientMalwareRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.bad_ip_url_info_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.referrer_url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.population_)*/nullptr} {}
+struct ClientMalwareRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientMalwareRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientMalwareRequestDefaultTypeInternal() {}
+  union {
+    ClientMalwareRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientMalwareRequestDefaultTypeInternal _ClientMalwareRequest_default_instance_;
+PROTOBUF_CONSTEXPR LoginReputationClientRequest_Frame_Form::LoginReputationClientRequest_Frame_Form(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.action_url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.has_password_field_)*/false} {}
+struct LoginReputationClientRequest_Frame_FormDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR LoginReputationClientRequest_Frame_FormDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~LoginReputationClientRequest_Frame_FormDefaultTypeInternal() {}
+  union {
+    LoginReputationClientRequest_Frame_Form _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoginReputationClientRequest_Frame_FormDefaultTypeInternal _LoginReputationClientRequest_Frame_Form_default_instance_;
+PROTOBUF_CONSTEXPR LoginReputationClientRequest_Frame::LoginReputationClientRequest_Frame(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.referrer_chain_)*/{}
+  , /*decltype(_impl_.forms_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.frame_index_)*/0
+  , /*decltype(_impl_.parent_frame_index_)*/0
+  , /*decltype(_impl_.has_password_field_)*/false} {}
+struct LoginReputationClientRequest_FrameDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR LoginReputationClientRequest_FrameDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~LoginReputationClientRequest_FrameDefaultTypeInternal() {}
+  union {
+    LoginReputationClientRequest_Frame _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoginReputationClientRequest_FrameDefaultTypeInternal _LoginReputationClientRequest_Frame_default_instance_;
+PROTOBUF_CONSTEXPR LoginReputationClientRequest_PasswordReuseEvent::LoginReputationClientRequest_PasswordReuseEvent(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.domains_matching_password_)*/{}
+  , /*decltype(_impl_.frame_id_)*/0
+  , /*decltype(_impl_.is_chrome_signin_password_)*/false
+  , /*decltype(_impl_.sync_account_type_)*/0} {}
+struct LoginReputationClientRequest_PasswordReuseEventDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR LoginReputationClientRequest_PasswordReuseEventDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~LoginReputationClientRequest_PasswordReuseEventDefaultTypeInternal() {}
+  union {
+    LoginReputationClientRequest_PasswordReuseEvent _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoginReputationClientRequest_PasswordReuseEventDefaultTypeInternal _LoginReputationClientRequest_PasswordReuseEvent_default_instance_;
+PROTOBUF_CONSTEXPR LoginReputationClientRequest::LoginReputationClientRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.frames_)*/{}
+  , /*decltype(_impl_.page_url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.password_reuse_event_)*/nullptr
+  , /*decltype(_impl_.population_)*/nullptr
+  , /*decltype(_impl_.trigger_type_)*/0
+  , /*decltype(_impl_.stored_verdict_cnt_)*/0
+  , /*decltype(_impl_.clicked_through_interstitial_)*/false} {}
+struct LoginReputationClientRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR LoginReputationClientRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~LoginReputationClientRequestDefaultTypeInternal() {}
+  union {
+    LoginReputationClientRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoginReputationClientRequestDefaultTypeInternal _LoginReputationClientRequest_default_instance_;
+PROTOBUF_CONSTEXPR LoginReputationClientResponse::LoginReputationClientResponse(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.cache_expression_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.verdict_token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.cache_duration_sec_)*/int64_t{0}
+  , /*decltype(_impl_.verdict_type_)*/0
+  , /*decltype(_impl_.deprecated_cache_expression_exact_match_)*/false} {}
+struct LoginReputationClientResponseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR LoginReputationClientResponseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~LoginReputationClientResponseDefaultTypeInternal() {}
+  union {
+    LoginReputationClientResponse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoginReputationClientResponseDefaultTypeInternal _LoginReputationClientResponse_default_instance_;
+PROTOBUF_CONSTEXPR ClientMalwareResponse::ClientMalwareResponse(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.bad_ip_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.bad_url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.blacklist_)*/false} {}
+struct ClientMalwareResponseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientMalwareResponseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientMalwareResponseDefaultTypeInternal() {}
+  union {
+    ClientMalwareResponse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientMalwareResponseDefaultTypeInternal _ClientMalwareResponse_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadRequest_Digests::ClientDownloadRequest_Digests(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.sha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.sha1_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.md5_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ClientDownloadRequest_DigestsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadRequest_DigestsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadRequest_DigestsDefaultTypeInternal() {}
+  union {
+    ClientDownloadRequest_Digests _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadRequest_DigestsDefaultTypeInternal _ClientDownloadRequest_Digests_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadRequest_Resource::ClientDownloadRequest_Resource(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.remote_ip_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.referrer_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.type_)*/0} {}
+struct ClientDownloadRequest_ResourceDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadRequest_ResourceDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadRequest_ResourceDefaultTypeInternal() {}
+  union {
+    ClientDownloadRequest_Resource _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadRequest_ResourceDefaultTypeInternal _ClientDownloadRequest_Resource_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadRequest_CertificateChain_Element::ClientDownloadRequest_CertificateChain_Element(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.certificate_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ClientDownloadRequest_CertificateChain_ElementDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadRequest_CertificateChain_ElementDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadRequest_CertificateChain_ElementDefaultTypeInternal() {}
+  union {
+    ClientDownloadRequest_CertificateChain_Element _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadRequest_CertificateChain_ElementDefaultTypeInternal _ClientDownloadRequest_CertificateChain_Element_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadRequest_CertificateChain::ClientDownloadRequest_CertificateChain(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_.element_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}} {}
+struct ClientDownloadRequest_CertificateChainDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadRequest_CertificateChainDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadRequest_CertificateChainDefaultTypeInternal() {}
+  union {
+    ClientDownloadRequest_CertificateChain _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadRequest_CertificateChainDefaultTypeInternal _ClientDownloadRequest_CertificateChain_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadRequest_ExtendedAttr::ClientDownloadRequest_ExtendedAttr(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ClientDownloadRequest_ExtendedAttrDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadRequest_ExtendedAttrDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadRequest_ExtendedAttrDefaultTypeInternal() {}
+  union {
+    ClientDownloadRequest_ExtendedAttr _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadRequest_ExtendedAttrDefaultTypeInternal _ClientDownloadRequest_ExtendedAttr_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadRequest_SignatureInfo::ClientDownloadRequest_SignatureInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.certificate_chain_)*/{}
+  , /*decltype(_impl_.signed_data_)*/{}
+  , /*decltype(_impl_.xattr_)*/{}
+  , /*decltype(_impl_.trusted_)*/false} {}
+struct ClientDownloadRequest_SignatureInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadRequest_SignatureInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadRequest_SignatureInfoDefaultTypeInternal() {}
+  union {
+    ClientDownloadRequest_SignatureInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadRequest_SignatureInfoDefaultTypeInternal _ClientDownloadRequest_SignatureInfo_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadRequest_PEImageHeaders_DebugData::ClientDownloadRequest_PEImageHeaders_DebugData(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.directory_entry_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.raw_data_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ClientDownloadRequest_PEImageHeaders_DebugDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadRequest_PEImageHeaders_DebugDataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadRequest_PEImageHeaders_DebugDataDefaultTypeInternal() {}
+  union {
+    ClientDownloadRequest_PEImageHeaders_DebugData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadRequest_PEImageHeaders_DebugDataDefaultTypeInternal _ClientDownloadRequest_PEImageHeaders_DebugData_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadRequest_PEImageHeaders::ClientDownloadRequest_PEImageHeaders(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.section_header_)*/{}
+  , /*decltype(_impl_.debug_data_)*/{}
+  , /*decltype(_impl_.dos_header_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.file_header_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.optional_headers32_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.optional_headers64_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.export_section_data_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ClientDownloadRequest_PEImageHeadersDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadRequest_PEImageHeadersDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadRequest_PEImageHeadersDefaultTypeInternal() {}
+  union {
+    ClientDownloadRequest_PEImageHeaders _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadRequest_PEImageHeadersDefaultTypeInternal _ClientDownloadRequest_PEImageHeaders_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadRequest_MachOHeaders_LoadCommand::ClientDownloadRequest_MachOHeaders_LoadCommand(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.command_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.command_id_)*/0u} {}
+struct ClientDownloadRequest_MachOHeaders_LoadCommandDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadRequest_MachOHeaders_LoadCommandDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadRequest_MachOHeaders_LoadCommandDefaultTypeInternal() {}
+  union {
+    ClientDownloadRequest_MachOHeaders_LoadCommand _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadRequest_MachOHeaders_LoadCommandDefaultTypeInternal _ClientDownloadRequest_MachOHeaders_LoadCommand_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadRequest_MachOHeaders::ClientDownloadRequest_MachOHeaders(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.load_commands_)*/{}
+  , /*decltype(_impl_.mach_header_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ClientDownloadRequest_MachOHeadersDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadRequest_MachOHeadersDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadRequest_MachOHeadersDefaultTypeInternal() {}
+  union {
+    ClientDownloadRequest_MachOHeaders _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadRequest_MachOHeadersDefaultTypeInternal _ClientDownloadRequest_MachOHeaders_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadRequest_ImageHeaders::ClientDownloadRequest_ImageHeaders(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.mach_o_headers_)*/{}
+  , /*decltype(_impl_.pe_headers_)*/nullptr} {}
+struct ClientDownloadRequest_ImageHeadersDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadRequest_ImageHeadersDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadRequest_ImageHeadersDefaultTypeInternal() {}
+  union {
+    ClientDownloadRequest_ImageHeaders _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadRequest_ImageHeadersDefaultTypeInternal _ClientDownloadRequest_ImageHeaders_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadRequest_ArchivedBinary::ClientDownloadRequest_ArchivedBinary(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.file_basename_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.digests_)*/nullptr
+  , /*decltype(_impl_.signature_)*/nullptr
+  , /*decltype(_impl_.image_headers_)*/nullptr
+  , /*decltype(_impl_.length_)*/int64_t{0}
+  , /*decltype(_impl_.download_type_)*/0} {}
+struct ClientDownloadRequest_ArchivedBinaryDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadRequest_ArchivedBinaryDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadRequest_ArchivedBinaryDefaultTypeInternal() {}
+  union {
+    ClientDownloadRequest_ArchivedBinary _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadRequest_ArchivedBinaryDefaultTypeInternal _ClientDownloadRequest_ArchivedBinary_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadRequest::ClientDownloadRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.resources_)*/{}
+  , /*decltype(_impl_.archived_binary_)*/{}
+  , /*decltype(_impl_.alternate_extensions_)*/{}
+  , /*decltype(_impl_.referrer_chain_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.file_basename_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.locale_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.udif_code_signature_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.digests_)*/nullptr
+  , /*decltype(_impl_.signature_)*/nullptr
+  , /*decltype(_impl_.image_headers_)*/nullptr
+  , /*decltype(_impl_.population_)*/nullptr
+  , /*decltype(_impl_.length_)*/int64_t{0}
+  , /*decltype(_impl_.download_type_)*/0
+  , /*decltype(_impl_.user_initiated_)*/false
+  , /*decltype(_impl_.archive_valid_)*/false
+  , /*decltype(_impl_.skipped_url_whitelist_)*/false
+  , /*decltype(_impl_.skipped_certificate_whitelist_)*/false
+  , /*decltype(_impl_.deprecated_download_attribution_finch_enabled_)*/false} {}
+struct ClientDownloadRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadRequestDefaultTypeInternal() {}
+  union {
+    ClientDownloadRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadRequestDefaultTypeInternal _ClientDownloadRequest_default_instance_;
+PROTOBUF_CONSTEXPR ReferrerChainEntry_ServerRedirect::ReferrerChainEntry_ServerRedirect(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ReferrerChainEntry_ServerRedirectDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ReferrerChainEntry_ServerRedirectDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ReferrerChainEntry_ServerRedirectDefaultTypeInternal() {}
+  union {
+    ReferrerChainEntry_ServerRedirect _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReferrerChainEntry_ServerRedirectDefaultTypeInternal _ReferrerChainEntry_ServerRedirect_default_instance_;
+PROTOBUF_CONSTEXPR ReferrerChainEntry::ReferrerChainEntry(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.ip_addresses_)*/{}
+  , /*decltype(_impl_.server_redirect_chain_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.referrer_url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.referrer_main_frame_url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.main_frame_url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.navigation_time_msec_)*/0
+  , /*decltype(_impl_.is_retargeting_)*/false
+  , /*decltype(_impl_.type_)*/4} {}
+struct ReferrerChainEntryDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ReferrerChainEntryDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ReferrerChainEntryDefaultTypeInternal() {}
+  union {
+    ReferrerChainEntry _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ReferrerChainEntryDefaultTypeInternal _ReferrerChainEntry_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadResponse_MoreInfo::ClientDownloadResponse_MoreInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ClientDownloadResponse_MoreInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadResponse_MoreInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadResponse_MoreInfoDefaultTypeInternal() {}
+  union {
+    ClientDownloadResponse_MoreInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadResponse_MoreInfoDefaultTypeInternal _ClientDownloadResponse_MoreInfo_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadResponse::ClientDownloadResponse(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.more_info_)*/nullptr
+  , /*decltype(_impl_.verdict_)*/0
+  , /*decltype(_impl_.upload_)*/false} {}
+struct ClientDownloadResponseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadResponseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadResponseDefaultTypeInternal() {}
+  union {
+    ClientDownloadResponse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadResponseDefaultTypeInternal _ClientDownloadResponse_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadReport_UserInformation::ClientDownloadReport_UserInformation(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.email_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ClientDownloadReport_UserInformationDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadReport_UserInformationDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadReport_UserInformationDefaultTypeInternal() {}
+  union {
+    ClientDownloadReport_UserInformation _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadReport_UserInformationDefaultTypeInternal _ClientDownloadReport_UserInformation_default_instance_;
+PROTOBUF_CONSTEXPR ClientDownloadReport::ClientDownloadReport(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.comment_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.download_request_)*/nullptr
+  , /*decltype(_impl_.user_information_)*/nullptr
+  , /*decltype(_impl_.download_response_)*/nullptr
+  , /*decltype(_impl_.reason_)*/0} {}
+struct ClientDownloadReportDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientDownloadReportDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientDownloadReportDefaultTypeInternal() {}
+  union {
+    ClientDownloadReport _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientDownloadReportDefaultTypeInternal _ClientDownloadReport_default_instance_;
+PROTOBUF_CONSTEXPR ClientUploadResponse::ClientUploadResponse(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.permalink_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.status_)*/0} {}
+struct ClientUploadResponseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientUploadResponseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientUploadResponseDefaultTypeInternal() {}
+  union {
+    ClientUploadResponse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientUploadResponseDefaultTypeInternal _ClientUploadResponse_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ClientIncidentReport_IncidentData_TrackedPreferenceIncident(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.split_key_)*/{}
+  , /*decltype(_impl_.path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.atomic_value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.value_state_)*/0} {}
+struct ClientIncidentReport_IncidentData_TrackedPreferenceIncidentDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData_TrackedPreferenceIncidentDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_IncidentData_TrackedPreferenceIncidentDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_IncidentData_TrackedPreferenceIncidentDefaultTypeInternal _ClientIncidentReport_IncidentData_TrackedPreferenceIncident_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.relative_path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.signature_)*/nullptr
+  , /*decltype(_impl_.image_headers_)*/nullptr} {}
+struct ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFileDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFileDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFileDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFileDefaultTypeInternal _ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData_BinaryIntegrityIncident::ClientIncidentReport_IncidentData_BinaryIntegrityIncident(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.contained_file_)*/{}
+  , /*decltype(_impl_.file_basename_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.signature_)*/nullptr
+  , /*decltype(_impl_.image_headers_)*/nullptr
+  , /*decltype(_impl_.sec_error_)*/0} {}
+struct ClientIncidentReport_IncidentData_BinaryIntegrityIncidentDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData_BinaryIntegrityIncidentDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_IncidentData_BinaryIntegrityIncidentDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_IncidentData_BinaryIntegrityIncident _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_IncidentData_BinaryIntegrityIncidentDefaultTypeInternal _ClientIncidentReport_IncidentData_BinaryIntegrityIncident_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData_ResourceRequestIncident::ClientIncidentReport_IncidentData_ResourceRequestIncident(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.digest_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.origin_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.type_)*/0} {}
+struct ClientIncidentReport_IncidentData_ResourceRequestIncidentDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData_ResourceRequestIncidentDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_IncidentData_ResourceRequestIncidentDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_IncidentData_ResourceRequestIncident _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_IncidentData_ResourceRequestIncidentDefaultTypeInternal _ClientIncidentReport_IncidentData_ResourceRequestIncident_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData::ClientIncidentReport_IncidentData(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.tracked_preference_)*/nullptr
+  , /*decltype(_impl_.binary_integrity_)*/nullptr
+  , /*decltype(_impl_.resource_request_)*/nullptr
+  , /*decltype(_impl_.incident_time_msec_)*/int64_t{0}} {}
+struct ClientIncidentReport_IncidentDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentDataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_IncidentDataDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_IncidentData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_IncidentDataDefaultTypeInternal _ClientIncidentReport_IncidentData_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_DownloadDetails::ClientIncidentReport_DownloadDetails(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.download_)*/nullptr
+  , /*decltype(_impl_.download_time_msec_)*/int64_t{0}
+  , /*decltype(_impl_.open_time_msec_)*/int64_t{0}} {}
+struct ClientIncidentReport_DownloadDetailsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_DownloadDetailsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_DownloadDetailsDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_DownloadDetails _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_DownloadDetailsDefaultTypeInternal _ClientIncidentReport_DownloadDetails_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_OS_RegistryValue::ClientIncidentReport_EnvironmentData_OS_RegistryValue(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.data_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.type_)*/0u} {}
+struct ClientIncidentReport_EnvironmentData_OS_RegistryValueDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_OS_RegistryValueDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_EnvironmentData_OS_RegistryValueDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_EnvironmentData_OS_RegistryValue _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_EnvironmentData_OS_RegistryValueDefaultTypeInternal _ClientIncidentReport_EnvironmentData_OS_RegistryValue_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_OS_RegistryKey::ClientIncidentReport_EnvironmentData_OS_RegistryKey(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.value_)*/{}
+  , /*decltype(_impl_.key_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ClientIncidentReport_EnvironmentData_OS_RegistryKeyDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_OS_RegistryKeyDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_EnvironmentData_OS_RegistryKeyDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_EnvironmentData_OS_RegistryKey _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_EnvironmentData_OS_RegistryKeyDefaultTypeInternal _ClientIncidentReport_EnvironmentData_OS_RegistryKey_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_OS::ClientIncidentReport_EnvironmentData_OS(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.registry_key_)*/{}
+  , /*decltype(_impl_.os_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.os_version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.is_enrolled_to_domain_)*/false} {}
+struct ClientIncidentReport_EnvironmentData_OSDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_OSDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_EnvironmentData_OSDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_EnvironmentData_OS _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_EnvironmentData_OSDefaultTypeInternal _ClientIncidentReport_EnvironmentData_OS_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Machine::ClientIncidentReport_EnvironmentData_Machine(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.cpu_architecture_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.cpu_vendor_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.cpuid_)*/0u} {}
+struct ClientIncidentReport_EnvironmentData_MachineDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_MachineDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_EnvironmentData_MachineDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_EnvironmentData_Machine _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_EnvironmentData_MachineDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Machine_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_Patch::ClientIncidentReport_EnvironmentData_Process_Patch(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.function_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.target_dll_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ClientIncidentReport_EnvironmentData_Process_PatchDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_PatchDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_EnvironmentData_Process_PatchDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_EnvironmentData_Process_Patch _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_EnvironmentData_Process_PatchDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_Patch_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_NetworkProvider::ClientIncidentReport_EnvironmentData_Process_NetworkProvider(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._cached_size_)*/{}} {}
+struct ClientIncidentReport_EnvironmentData_Process_NetworkProviderDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_NetworkProviderDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_EnvironmentData_Process_NetworkProviderDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_EnvironmentData_Process_NetworkProvider _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_EnvironmentData_Process_NetworkProviderDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_NetworkProvider_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_Dll::ClientIncidentReport_EnvironmentData_Process_Dll(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.feature_)*/{}
+  , /*decltype(_impl_.path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.image_headers_)*/nullptr
+  , /*decltype(_impl_.base_address_)*/uint64_t{0u}
+  , /*decltype(_impl_.length_)*/0u} {}
+struct ClientIncidentReport_EnvironmentData_Process_DllDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_DllDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_EnvironmentData_Process_DllDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_EnvironmentData_Process_Dll _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_EnvironmentData_Process_DllDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_Dll_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.modified_bytes_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.export_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.file_offset_)*/0u
+  , /*decltype(_impl_.byte_count_)*/0} {}
+struct ClientIncidentReport_EnvironmentData_Process_ModuleState_ModificationDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_ModuleState_ModificationDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_EnvironmentData_Process_ModuleState_ModificationDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_EnvironmentData_Process_ModuleState_ModificationDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_ModuleState::ClientIncidentReport_EnvironmentData_Process_ModuleState(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.obsolete_modified_export_)*/{}
+  , /*decltype(_impl_.modification_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.modified_state_)*/0} {}
+struct ClientIncidentReport_EnvironmentData_Process_ModuleStateDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_ModuleStateDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_EnvironmentData_Process_ModuleStateDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_EnvironmentData_Process_ModuleState _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_EnvironmentData_Process_ModuleStateDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_ModuleState_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process::ClientIncidentReport_EnvironmentData_Process(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.obsolete_dlls_)*/{}
+  , /*decltype(_impl_.patches_)*/{}
+  , /*decltype(_impl_.network_providers_)*/{}
+  , /*decltype(_impl_.dll_)*/{}
+  , /*decltype(_impl_.blacklisted_dll_)*/{}
+  , /*decltype(_impl_.module_state_)*/{}
+  , /*decltype(_impl_.version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.uptime_msec_)*/int64_t{0}
+  , /*decltype(_impl_.chrome_update_channel_)*/0
+  , /*decltype(_impl_.metrics_consent_)*/false
+  , /*decltype(_impl_.obsolete_extended_consent_)*/false
+  , /*decltype(_impl_.obsolete_field_trial_participant_)*/false} {}
+struct ClientIncidentReport_EnvironmentData_ProcessDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_ProcessDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_EnvironmentData_ProcessDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_EnvironmentData_Process _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_EnvironmentData_ProcessDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData::ClientIncidentReport_EnvironmentData(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.os_)*/nullptr
+  , /*decltype(_impl_.machine_)*/nullptr
+  , /*decltype(_impl_.process_)*/nullptr} {}
+struct ClientIncidentReport_EnvironmentDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentDataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_EnvironmentDataDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_EnvironmentData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_EnvironmentDataDefaultTypeInternal _ClientIncidentReport_EnvironmentData_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_ExtensionData_ExtensionInfo::ClientIncidentReport_ExtensionData_ExtensionInfo(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.id_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.update_url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.manifest_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.state_)*/0
+  , /*decltype(_impl_.type_)*/0
+  , /*decltype(_impl_.has_signature_validation_)*/false
+  , /*decltype(_impl_.signature_is_valid_)*/false
+  , /*decltype(_impl_.installed_by_custodian_)*/false
+  , /*decltype(_impl_.installed_by_default_)*/false
+  , /*decltype(_impl_.installed_by_oem_)*/false
+  , /*decltype(_impl_.from_bookmark_)*/false
+  , /*decltype(_impl_.from_webstore_)*/false
+  , /*decltype(_impl_.converted_from_user_script_)*/false
+  , /*decltype(_impl_.install_time_msec_)*/int64_t{0}
+  , /*decltype(_impl_.may_be_untrusted_)*/false
+  , /*decltype(_impl_.manifest_location_type_)*/0} {}
+struct ClientIncidentReport_ExtensionData_ExtensionInfoDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_ExtensionData_ExtensionInfoDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_ExtensionData_ExtensionInfoDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_ExtensionData_ExtensionInfo _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_ExtensionData_ExtensionInfoDefaultTypeInternal _ClientIncidentReport_ExtensionData_ExtensionInfo_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_ExtensionData::ClientIncidentReport_ExtensionData(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.last_installed_extension_)*/nullptr} {}
+struct ClientIncidentReport_ExtensionDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_ExtensionDataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_ExtensionDataDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_ExtensionData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_ExtensionDataDefaultTypeInternal _ClientIncidentReport_ExtensionData_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport_NonBinaryDownloadDetails::ClientIncidentReport_NonBinaryDownloadDetails(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.file_type_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.url_spec_sha256_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.host_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.length_)*/int64_t{0}} {}
+struct ClientIncidentReport_NonBinaryDownloadDetailsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReport_NonBinaryDownloadDetailsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReport_NonBinaryDownloadDetailsDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport_NonBinaryDownloadDetails _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReport_NonBinaryDownloadDetailsDefaultTypeInternal _ClientIncidentReport_NonBinaryDownloadDetails_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentReport::ClientIncidentReport(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.incident_)*/{}
+  , /*decltype(_impl_.download_)*/nullptr
+  , /*decltype(_impl_.environment_)*/nullptr
+  , /*decltype(_impl_.population_)*/nullptr
+  , /*decltype(_impl_.extension_data_)*/nullptr
+  , /*decltype(_impl_.non_binary_download_)*/nullptr} {}
+struct ClientIncidentReportDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentReportDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentReportDefaultTypeInternal() {}
+  union {
+    ClientIncidentReport _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentReportDefaultTypeInternal _ClientIncidentReport_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentResponse_EnvironmentRequest::ClientIncidentResponse_EnvironmentRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.dll_index_)*/0} {}
+struct ClientIncidentResponse_EnvironmentRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentResponse_EnvironmentRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentResponse_EnvironmentRequestDefaultTypeInternal() {}
+  union {
+    ClientIncidentResponse_EnvironmentRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentResponse_EnvironmentRequestDefaultTypeInternal _ClientIncidentResponse_EnvironmentRequest_default_instance_;
+PROTOBUF_CONSTEXPR ClientIncidentResponse::ClientIncidentResponse(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.environment_requests_)*/{}
+  , /*decltype(_impl_.token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.download_requested_)*/false} {}
+struct ClientIncidentResponseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientIncidentResponseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientIncidentResponseDefaultTypeInternal() {}
+  union {
+    ClientIncidentResponse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientIncidentResponseDefaultTypeInternal _ClientIncidentResponse_default_instance_;
+PROTOBUF_CONSTEXPR DownloadMetadata::DownloadMetadata(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.download_)*/nullptr
+  , /*decltype(_impl_.download_id_)*/0u} {}
+struct DownloadMetadataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR DownloadMetadataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~DownloadMetadataDefaultTypeInternal() {}
+  union {
+    DownloadMetadata _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DownloadMetadataDefaultTypeInternal _DownloadMetadata_default_instance_;
+PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPHeader::ClientSafeBrowsingReportRequest_HTTPHeader(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ClientSafeBrowsingReportRequest_HTTPHeaderDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPHeaderDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientSafeBrowsingReportRequest_HTTPHeaderDefaultTypeInternal() {}
+  union {
+    ClientSafeBrowsingReportRequest_HTTPHeader _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientSafeBrowsingReportRequest_HTTPHeaderDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPHeader_default_instance_;
+PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.verb_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.uri_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct ClientSafeBrowsingReportRequest_HTTPRequest_FirstLineDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPRequest_FirstLineDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientSafeBrowsingReportRequest_HTTPRequest_FirstLineDefaultTypeInternal() {}
+  union {
+    ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientSafeBrowsingReportRequest_HTTPRequest_FirstLineDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_default_instance_;
+PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPRequest::ClientSafeBrowsingReportRequest_HTTPRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.headers_)*/{}
+  , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.bodydigest_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.firstline_)*/nullptr
+  , /*decltype(_impl_.bodylength_)*/0} {}
+struct ClientSafeBrowsingReportRequest_HTTPRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientSafeBrowsingReportRequest_HTTPRequestDefaultTypeInternal() {}
+  union {
+    ClientSafeBrowsingReportRequest_HTTPRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientSafeBrowsingReportRequest_HTTPRequestDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPRequest_default_instance_;
+PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.code_)*/0} {}
+struct ClientSafeBrowsingReportRequest_HTTPResponse_FirstLineDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPResponse_FirstLineDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientSafeBrowsingReportRequest_HTTPResponse_FirstLineDefaultTypeInternal() {}
+  union {
+    ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientSafeBrowsingReportRequest_HTTPResponse_FirstLineDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_default_instance_;
+PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPResponse::ClientSafeBrowsingReportRequest_HTTPResponse(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.headers_)*/{}
+  , /*decltype(_impl_.body_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.bodydigest_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.remote_ip_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.firstline_)*/nullptr
+  , /*decltype(_impl_.bodylength_)*/0} {}
+struct ClientSafeBrowsingReportRequest_HTTPResponseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPResponseDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientSafeBrowsingReportRequest_HTTPResponseDefaultTypeInternal() {}
+  union {
+    ClientSafeBrowsingReportRequest_HTTPResponse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientSafeBrowsingReportRequest_HTTPResponseDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPResponse_default_instance_;
+PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_Resource::ClientSafeBrowsingReportRequest_Resource(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.child_ids_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.tag_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.request_)*/nullptr
+  , /*decltype(_impl_.response_)*/nullptr
+  , /*decltype(_impl_.id_)*/0
+  , /*decltype(_impl_.parent_id_)*/0} {}
+struct ClientSafeBrowsingReportRequest_ResourceDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_ResourceDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientSafeBrowsingReportRequest_ResourceDefaultTypeInternal() {}
+  union {
+    ClientSafeBrowsingReportRequest_Resource _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientSafeBrowsingReportRequest_ResourceDefaultTypeInternal _ClientSafeBrowsingReportRequest_Resource_default_instance_;
+PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.client_version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.google_play_services_version_)*/int64_t{0}
+  , /*decltype(_impl_.is_instant_apps_)*/false
+  , /*decltype(_impl_.url_api_type_)*/0} {}
+struct ClientSafeBrowsingReportRequest_SafeBrowsingClientPropertiesDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_SafeBrowsingClientPropertiesDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientSafeBrowsingReportRequest_SafeBrowsingClientPropertiesDefaultTypeInternal() {}
+  union {
+    ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientSafeBrowsingReportRequest_SafeBrowsingClientPropertiesDefaultTypeInternal _ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_default_instance_;
+PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest::ClientSafeBrowsingReportRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.resources_)*/{}
+  , /*decltype(_impl_.client_asn_)*/{}
+  , /*decltype(_impl_.dom_)*/{}
+  , /*decltype(_impl_.url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.page_url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.referrer_url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.client_country_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.token_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.client_properties_)*/nullptr
+  , /*decltype(_impl_.type_)*/0
+  , /*decltype(_impl_.complete_)*/false
+  , /*decltype(_impl_.did_proceed_)*/false
+  , /*decltype(_impl_.repeat_visit_)*/false
+  , /*decltype(_impl_.show_download_in_folder_)*/false
+  , /*decltype(_impl_.download_verdict_)*/0} {}
+struct ClientSafeBrowsingReportRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ClientSafeBrowsingReportRequestDefaultTypeInternal() {}
+  union {
+    ClientSafeBrowsingReportRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientSafeBrowsingReportRequestDefaultTypeInternal _ClientSafeBrowsingReportRequest_default_instance_;
+PROTOBUF_CONSTEXPR HTMLElement_Attribute::HTMLElement_Attribute(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
+struct HTMLElement_AttributeDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HTMLElement_AttributeDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HTMLElement_AttributeDefaultTypeInternal() {}
+  union {
+    HTMLElement_Attribute _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HTMLElement_AttributeDefaultTypeInternal _HTMLElement_Attribute_default_instance_;
+PROTOBUF_CONSTEXPR HTMLElement::HTMLElement(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.child_ids_)*/{}
+  , /*decltype(_impl_.attribute_)*/{}
+  , /*decltype(_impl_.tag_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.id_)*/0
+  , /*decltype(_impl_.resource_id_)*/0} {}
+struct HTMLElementDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HTMLElementDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HTMLElementDefaultTypeInternal() {}
+  union {
+    HTMLElement _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HTMLElementDefaultTypeInternal _HTMLElement_default_instance_;
+PROTOBUF_CONSTEXPR ImageData_Dimensions::ImageData_Dimensions(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.width_)*/0
+  , /*decltype(_impl_.height_)*/0} {}
+struct ImageData_DimensionsDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ImageData_DimensionsDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ImageData_DimensionsDefaultTypeInternal() {}
+  union {
+    ImageData_Dimensions _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ImageData_DimensionsDefaultTypeInternal _ImageData_Dimensions_default_instance_;
+PROTOBUF_CONSTEXPR ImageData::ImageData(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.data_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.mime_type_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.dimensions_)*/nullptr
+  , /*decltype(_impl_.original_dimensions_)*/nullptr} {}
+struct ImageDataDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR ImageDataDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~ImageDataDefaultTypeInternal() {}
+  union {
+    ImageData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ImageDataDefaultTypeInternal _ImageData_default_instance_;
+PROTOBUF_CONSTEXPR NotificationImageReportRequest::NotificationImageReportRequest(
+    ::_pbi::ConstantInitialized): _impl_{
+    /*decltype(_impl_._has_bits_)*/{}
+  , /*decltype(_impl_._cached_size_)*/{}
+  , /*decltype(_impl_.notification_origin_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
+  , /*decltype(_impl_.image_)*/nullptr} {}
+struct NotificationImageReportRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR NotificationImageReportRequestDefaultTypeInternal()
+      : _instance(::_pbi::ConstantInitialized{}) {}
+  ~NotificationImageReportRequestDefaultTypeInternal() {}
+  union {
+    NotificationImageReportRequest _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NotificationImageReportRequestDefaultTypeInternal _NotificationImageReportRequest_default_instance_;
+}  // namespace safe_browsing
+namespace safe_browsing {
+bool ChromeUserPopulation_UserPopulation_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ChromeUserPopulation_UserPopulation_strings[3] = {};
+
+static const char ChromeUserPopulation_UserPopulation_names[] =
+  "EXTENDED_REPORTING"
+  "SAFE_BROWSING"
+  "UNKNOWN_USER_POPULATION";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ChromeUserPopulation_UserPopulation_entries[] = {
+  { {ChromeUserPopulation_UserPopulation_names + 0, 18}, 2 },
+  { {ChromeUserPopulation_UserPopulation_names + 18, 13}, 1 },
+  { {ChromeUserPopulation_UserPopulation_names + 31, 23}, 0 },
+};
+
+static const int ChromeUserPopulation_UserPopulation_entries_by_number[] = {
+  2, // 0 -> UNKNOWN_USER_POPULATION
+  1, // 1 -> SAFE_BROWSING
+  0, // 2 -> EXTENDED_REPORTING
+};
+
+const std::string& ChromeUserPopulation_UserPopulation_Name(
+    ChromeUserPopulation_UserPopulation value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ChromeUserPopulation_UserPopulation_entries,
+          ChromeUserPopulation_UserPopulation_entries_by_number,
+          3, ChromeUserPopulation_UserPopulation_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ChromeUserPopulation_UserPopulation_entries,
+      ChromeUserPopulation_UserPopulation_entries_by_number,
+      3, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ChromeUserPopulation_UserPopulation_strings[idx].get();
+}
+bool ChromeUserPopulation_UserPopulation_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeUserPopulation_UserPopulation* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ChromeUserPopulation_UserPopulation_entries, 3, name, &int_value);
+  if (success) {
+    *value = static_cast<ChromeUserPopulation_UserPopulation>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ChromeUserPopulation_UserPopulation ChromeUserPopulation::UNKNOWN_USER_POPULATION;
+constexpr ChromeUserPopulation_UserPopulation ChromeUserPopulation::SAFE_BROWSING;
+constexpr ChromeUserPopulation_UserPopulation ChromeUserPopulation::EXTENDED_REPORTING;
+constexpr ChromeUserPopulation_UserPopulation ChromeUserPopulation::UserPopulation_MIN;
+constexpr ChromeUserPopulation_UserPopulation ChromeUserPopulation::UserPopulation_MAX;
+constexpr int ChromeUserPopulation::UserPopulation_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_strings[3] = {};
+
+static const char LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_names[] =
+  "GMAIL"
+  "GSUITE"
+  "NOT_SIGNED_IN";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_entries[] = {
+  { {LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_names + 0, 5}, 1 },
+  { {LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_names + 5, 6}, 2 },
+  { {LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_names + 11, 13}, 0 },
+};
+
+static const int LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_entries_by_number[] = {
+  2, // 0 -> NOT_SIGNED_IN
+  0, // 1 -> GMAIL
+  1, // 2 -> GSUITE
+};
+
+const std::string& LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_Name(
+    LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_entries,
+          LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_entries_by_number,
+          3, LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_entries,
+      LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_entries_by_number,
+      3, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_strings[idx].get();
+}
+bool LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_entries, 3, name, &int_value);
+  if (success) {
+    *value = static_cast<LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType LoginReputationClientRequest_PasswordReuseEvent::NOT_SIGNED_IN;
+constexpr LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType LoginReputationClientRequest_PasswordReuseEvent::GMAIL;
+constexpr LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType LoginReputationClientRequest_PasswordReuseEvent::GSUITE;
+constexpr LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType LoginReputationClientRequest_PasswordReuseEvent::SyncAccountType_MIN;
+constexpr LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType LoginReputationClientRequest_PasswordReuseEvent::SyncAccountType_MAX;
+constexpr int LoginReputationClientRequest_PasswordReuseEvent::SyncAccountType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool LoginReputationClientRequest_TriggerType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> LoginReputationClientRequest_TriggerType_strings[3] = {};
+
+static const char LoginReputationClientRequest_TriggerType_names[] =
+  "PASSWORD_REUSE_EVENT"
+  "TRIGGER_TYPE_UNSPECIFIED"
+  "UNFAMILIAR_LOGIN_PAGE";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry LoginReputationClientRequest_TriggerType_entries[] = {
+  { {LoginReputationClientRequest_TriggerType_names + 0, 20}, 2 },
+  { {LoginReputationClientRequest_TriggerType_names + 20, 24}, 0 },
+  { {LoginReputationClientRequest_TriggerType_names + 44, 21}, 1 },
+};
+
+static const int LoginReputationClientRequest_TriggerType_entries_by_number[] = {
+  1, // 0 -> TRIGGER_TYPE_UNSPECIFIED
+  2, // 1 -> UNFAMILIAR_LOGIN_PAGE
+  0, // 2 -> PASSWORD_REUSE_EVENT
+};
+
+const std::string& LoginReputationClientRequest_TriggerType_Name(
+    LoginReputationClientRequest_TriggerType value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          LoginReputationClientRequest_TriggerType_entries,
+          LoginReputationClientRequest_TriggerType_entries_by_number,
+          3, LoginReputationClientRequest_TriggerType_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      LoginReputationClientRequest_TriggerType_entries,
+      LoginReputationClientRequest_TriggerType_entries_by_number,
+      3, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     LoginReputationClientRequest_TriggerType_strings[idx].get();
+}
+bool LoginReputationClientRequest_TriggerType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LoginReputationClientRequest_TriggerType* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      LoginReputationClientRequest_TriggerType_entries, 3, name, &int_value);
+  if (success) {
+    *value = static_cast<LoginReputationClientRequest_TriggerType>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr LoginReputationClientRequest_TriggerType LoginReputationClientRequest::TRIGGER_TYPE_UNSPECIFIED;
+constexpr LoginReputationClientRequest_TriggerType LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE;
+constexpr LoginReputationClientRequest_TriggerType LoginReputationClientRequest::PASSWORD_REUSE_EVENT;
+constexpr LoginReputationClientRequest_TriggerType LoginReputationClientRequest::TriggerType_MIN;
+constexpr LoginReputationClientRequest_TriggerType LoginReputationClientRequest::TriggerType_MAX;
+constexpr int LoginReputationClientRequest::TriggerType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool LoginReputationClientResponse_VerdictType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> LoginReputationClientResponse_VerdictType_strings[4] = {};
+
+static const char LoginReputationClientResponse_VerdictType_names[] =
+  "LOW_REPUTATION"
+  "PHISHING"
+  "SAFE"
+  "VERDICT_TYPE_UNSPECIFIED";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry LoginReputationClientResponse_VerdictType_entries[] = {
+  { {LoginReputationClientResponse_VerdictType_names + 0, 14}, 2 },
+  { {LoginReputationClientResponse_VerdictType_names + 14, 8}, 3 },
+  { {LoginReputationClientResponse_VerdictType_names + 22, 4}, 1 },
+  { {LoginReputationClientResponse_VerdictType_names + 26, 24}, 0 },
+};
+
+static const int LoginReputationClientResponse_VerdictType_entries_by_number[] = {
+  3, // 0 -> VERDICT_TYPE_UNSPECIFIED
+  2, // 1 -> SAFE
+  0, // 2 -> LOW_REPUTATION
+  1, // 3 -> PHISHING
+};
+
+const std::string& LoginReputationClientResponse_VerdictType_Name(
+    LoginReputationClientResponse_VerdictType value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          LoginReputationClientResponse_VerdictType_entries,
+          LoginReputationClientResponse_VerdictType_entries_by_number,
+          4, LoginReputationClientResponse_VerdictType_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      LoginReputationClientResponse_VerdictType_entries,
+      LoginReputationClientResponse_VerdictType_entries_by_number,
+      4, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     LoginReputationClientResponse_VerdictType_strings[idx].get();
+}
+bool LoginReputationClientResponse_VerdictType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LoginReputationClientResponse_VerdictType* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      LoginReputationClientResponse_VerdictType_entries, 4, name, &int_value);
+  if (success) {
+    *value = static_cast<LoginReputationClientResponse_VerdictType>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr LoginReputationClientResponse_VerdictType LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED;
+constexpr LoginReputationClientResponse_VerdictType LoginReputationClientResponse::SAFE;
+constexpr LoginReputationClientResponse_VerdictType LoginReputationClientResponse::LOW_REPUTATION;
+constexpr LoginReputationClientResponse_VerdictType LoginReputationClientResponse::PHISHING;
+constexpr LoginReputationClientResponse_VerdictType LoginReputationClientResponse::VerdictType_MIN;
+constexpr LoginReputationClientResponse_VerdictType LoginReputationClientResponse::VerdictType_MAX;
+constexpr int LoginReputationClientResponse::VerdictType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ClientDownloadRequest_ResourceType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientDownloadRequest_ResourceType_strings[6] = {};
+
+static const char ClientDownloadRequest_ResourceType_names[] =
+  "DOWNLOAD_REDIRECT"
+  "DOWNLOAD_URL"
+  "PPAPI_DOCUMENT"
+  "PPAPI_PLUGIN"
+  "TAB_REDIRECT"
+  "TAB_URL";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientDownloadRequest_ResourceType_entries[] = {
+  { {ClientDownloadRequest_ResourceType_names + 0, 17}, 1 },
+  { {ClientDownloadRequest_ResourceType_names + 17, 12}, 0 },
+  { {ClientDownloadRequest_ResourceType_names + 29, 14}, 4 },
+  { {ClientDownloadRequest_ResourceType_names + 43, 12}, 5 },
+  { {ClientDownloadRequest_ResourceType_names + 55, 12}, 3 },
+  { {ClientDownloadRequest_ResourceType_names + 67, 7}, 2 },
+};
+
+static const int ClientDownloadRequest_ResourceType_entries_by_number[] = {
+  1, // 0 -> DOWNLOAD_URL
+  0, // 1 -> DOWNLOAD_REDIRECT
+  5, // 2 -> TAB_URL
+  4, // 3 -> TAB_REDIRECT
+  2, // 4 -> PPAPI_DOCUMENT
+  3, // 5 -> PPAPI_PLUGIN
+};
+
+const std::string& ClientDownloadRequest_ResourceType_Name(
+    ClientDownloadRequest_ResourceType value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ClientDownloadRequest_ResourceType_entries,
+          ClientDownloadRequest_ResourceType_entries_by_number,
+          6, ClientDownloadRequest_ResourceType_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ClientDownloadRequest_ResourceType_entries,
+      ClientDownloadRequest_ResourceType_entries_by_number,
+      6, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ClientDownloadRequest_ResourceType_strings[idx].get();
+}
+bool ClientDownloadRequest_ResourceType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientDownloadRequest_ResourceType* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ClientDownloadRequest_ResourceType_entries, 6, name, &int_value);
+  if (success) {
+    *value = static_cast<ClientDownloadRequest_ResourceType>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientDownloadRequest_ResourceType ClientDownloadRequest::DOWNLOAD_URL;
+constexpr ClientDownloadRequest_ResourceType ClientDownloadRequest::DOWNLOAD_REDIRECT;
+constexpr ClientDownloadRequest_ResourceType ClientDownloadRequest::TAB_URL;
+constexpr ClientDownloadRequest_ResourceType ClientDownloadRequest::TAB_REDIRECT;
+constexpr ClientDownloadRequest_ResourceType ClientDownloadRequest::PPAPI_DOCUMENT;
+constexpr ClientDownloadRequest_ResourceType ClientDownloadRequest::PPAPI_PLUGIN;
+constexpr ClientDownloadRequest_ResourceType ClientDownloadRequest::ResourceType_MIN;
+constexpr ClientDownloadRequest_ResourceType ClientDownloadRequest::ResourceType_MAX;
+constexpr int ClientDownloadRequest::ResourceType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ClientDownloadRequest_DownloadType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientDownloadRequest_DownloadType_strings[11] = {};
+
+static const char ClientDownloadRequest_DownloadType_names[] =
+  "ANDROID_APK"
+  "ARCHIVE"
+  "CHROME_EXTENSION"
+  "INVALID_MAC_ARCHIVE"
+  "INVALID_ZIP"
+  "MAC_EXECUTABLE"
+  "PPAPI_SAVE_REQUEST"
+  "SAMPLED_UNSUPPORTED_FILE"
+  "WIN_EXECUTABLE"
+  "ZIPPED_ARCHIVE"
+  "ZIPPED_EXECUTABLE";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientDownloadRequest_DownloadType_entries[] = {
+  { {ClientDownloadRequest_DownloadType_names + 0, 11}, 2 },
+  { {ClientDownloadRequest_DownloadType_names + 11, 7}, 6 },
+  { {ClientDownloadRequest_DownloadType_names + 18, 16}, 1 },
+  { {ClientDownloadRequest_DownloadType_names + 34, 19}, 8 },
+  { {ClientDownloadRequest_DownloadType_names + 53, 11}, 7 },
+  { {ClientDownloadRequest_DownloadType_names + 64, 14}, 4 },
+  { {ClientDownloadRequest_DownloadType_names + 78, 18}, 9 },
+  { {ClientDownloadRequest_DownloadType_names + 96, 24}, 10 },
+  { {ClientDownloadRequest_DownloadType_names + 120, 14}, 0 },
+  { {ClientDownloadRequest_DownloadType_names + 134, 14}, 5 },
+  { {ClientDownloadRequest_DownloadType_names + 148, 17}, 3 },
+};
+
+static const int ClientDownloadRequest_DownloadType_entries_by_number[] = {
+  8, // 0 -> WIN_EXECUTABLE
+  2, // 1 -> CHROME_EXTENSION
+  0, // 2 -> ANDROID_APK
+  10, // 3 -> ZIPPED_EXECUTABLE
+  5, // 4 -> MAC_EXECUTABLE
+  9, // 5 -> ZIPPED_ARCHIVE
+  1, // 6 -> ARCHIVE
+  4, // 7 -> INVALID_ZIP
+  3, // 8 -> INVALID_MAC_ARCHIVE
+  6, // 9 -> PPAPI_SAVE_REQUEST
+  7, // 10 -> SAMPLED_UNSUPPORTED_FILE
+};
+
+const std::string& ClientDownloadRequest_DownloadType_Name(
+    ClientDownloadRequest_DownloadType value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ClientDownloadRequest_DownloadType_entries,
+          ClientDownloadRequest_DownloadType_entries_by_number,
+          11, ClientDownloadRequest_DownloadType_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ClientDownloadRequest_DownloadType_entries,
+      ClientDownloadRequest_DownloadType_entries_by_number,
+      11, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ClientDownloadRequest_DownloadType_strings[idx].get();
+}
+bool ClientDownloadRequest_DownloadType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientDownloadRequest_DownloadType* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ClientDownloadRequest_DownloadType_entries, 11, name, &int_value);
+  if (success) {
+    *value = static_cast<ClientDownloadRequest_DownloadType>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest::WIN_EXECUTABLE;
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest::CHROME_EXTENSION;
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest::ANDROID_APK;
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest::ZIPPED_EXECUTABLE;
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest::MAC_EXECUTABLE;
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest::ZIPPED_ARCHIVE;
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest::ARCHIVE;
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest::INVALID_ZIP;
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest::INVALID_MAC_ARCHIVE;
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest::PPAPI_SAVE_REQUEST;
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest::SAMPLED_UNSUPPORTED_FILE;
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest::DownloadType_MIN;
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest::DownloadType_MAX;
+constexpr int ClientDownloadRequest::DownloadType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ReferrerChainEntry_URLType_IsValid(int value) {
+  switch (value) {
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ReferrerChainEntry_URLType_strings[5] = {};
+
+static const char ReferrerChainEntry_URLType_names[] =
+  "CLIENT_REDIRECT"
+  "DEPRECATED_SERVER_REDIRECT"
+  "EVENT_URL"
+  "LANDING_PAGE"
+  "LANDING_REFERRER";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ReferrerChainEntry_URLType_entries[] = {
+  { {ReferrerChainEntry_URLType_names + 0, 15}, 4 },
+  { {ReferrerChainEntry_URLType_names + 15, 26}, 5 },
+  { {ReferrerChainEntry_URLType_names + 41, 9}, 1 },
+  { {ReferrerChainEntry_URLType_names + 50, 12}, 2 },
+  { {ReferrerChainEntry_URLType_names + 62, 16}, 3 },
+};
+
+static const int ReferrerChainEntry_URLType_entries_by_number[] = {
+  2, // 1 -> EVENT_URL
+  3, // 2 -> LANDING_PAGE
+  4, // 3 -> LANDING_REFERRER
+  0, // 4 -> CLIENT_REDIRECT
+  1, // 5 -> DEPRECATED_SERVER_REDIRECT
+};
+
+const std::string& ReferrerChainEntry_URLType_Name(
+    ReferrerChainEntry_URLType value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ReferrerChainEntry_URLType_entries,
+          ReferrerChainEntry_URLType_entries_by_number,
+          5, ReferrerChainEntry_URLType_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ReferrerChainEntry_URLType_entries,
+      ReferrerChainEntry_URLType_entries_by_number,
+      5, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ReferrerChainEntry_URLType_strings[idx].get();
+}
+bool ReferrerChainEntry_URLType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReferrerChainEntry_URLType* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ReferrerChainEntry_URLType_entries, 5, name, &int_value);
+  if (success) {
+    *value = static_cast<ReferrerChainEntry_URLType>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ReferrerChainEntry_URLType ReferrerChainEntry::EVENT_URL;
+constexpr ReferrerChainEntry_URLType ReferrerChainEntry::LANDING_PAGE;
+constexpr ReferrerChainEntry_URLType ReferrerChainEntry::LANDING_REFERRER;
+constexpr ReferrerChainEntry_URLType ReferrerChainEntry::CLIENT_REDIRECT;
+constexpr ReferrerChainEntry_URLType ReferrerChainEntry::DEPRECATED_SERVER_REDIRECT;
+constexpr ReferrerChainEntry_URLType ReferrerChainEntry::URLType_MIN;
+constexpr ReferrerChainEntry_URLType ReferrerChainEntry::URLType_MAX;
+constexpr int ReferrerChainEntry::URLType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ClientDownloadResponse_Verdict_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientDownloadResponse_Verdict_strings[6] = {};
+
+static const char ClientDownloadResponse_Verdict_names[] =
+  "DANGEROUS"
+  "DANGEROUS_HOST"
+  "POTENTIALLY_UNWANTED"
+  "SAFE"
+  "UNCOMMON"
+  "UNKNOWN";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientDownloadResponse_Verdict_entries[] = {
+  { {ClientDownloadResponse_Verdict_names + 0, 9}, 1 },
+  { {ClientDownloadResponse_Verdict_names + 9, 14}, 4 },
+  { {ClientDownloadResponse_Verdict_names + 23, 20}, 3 },
+  { {ClientDownloadResponse_Verdict_names + 43, 4}, 0 },
+  { {ClientDownloadResponse_Verdict_names + 47, 8}, 2 },
+  { {ClientDownloadResponse_Verdict_names + 55, 7}, 5 },
+};
+
+static const int ClientDownloadResponse_Verdict_entries_by_number[] = {
+  3, // 0 -> SAFE
+  0, // 1 -> DANGEROUS
+  4, // 2 -> UNCOMMON
+  2, // 3 -> POTENTIALLY_UNWANTED
+  1, // 4 -> DANGEROUS_HOST
+  5, // 5 -> UNKNOWN
+};
+
+const std::string& ClientDownloadResponse_Verdict_Name(
+    ClientDownloadResponse_Verdict value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ClientDownloadResponse_Verdict_entries,
+          ClientDownloadResponse_Verdict_entries_by_number,
+          6, ClientDownloadResponse_Verdict_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ClientDownloadResponse_Verdict_entries,
+      ClientDownloadResponse_Verdict_entries_by_number,
+      6, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ClientDownloadResponse_Verdict_strings[idx].get();
+}
+bool ClientDownloadResponse_Verdict_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientDownloadResponse_Verdict* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ClientDownloadResponse_Verdict_entries, 6, name, &int_value);
+  if (success) {
+    *value = static_cast<ClientDownloadResponse_Verdict>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientDownloadResponse_Verdict ClientDownloadResponse::SAFE;
+constexpr ClientDownloadResponse_Verdict ClientDownloadResponse::DANGEROUS;
+constexpr ClientDownloadResponse_Verdict ClientDownloadResponse::UNCOMMON;
+constexpr ClientDownloadResponse_Verdict ClientDownloadResponse::POTENTIALLY_UNWANTED;
+constexpr ClientDownloadResponse_Verdict ClientDownloadResponse::DANGEROUS_HOST;
+constexpr ClientDownloadResponse_Verdict ClientDownloadResponse::UNKNOWN;
+constexpr ClientDownloadResponse_Verdict ClientDownloadResponse::Verdict_MIN;
+constexpr ClientDownloadResponse_Verdict ClientDownloadResponse::Verdict_MAX;
+constexpr int ClientDownloadResponse::Verdict_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ClientDownloadReport_Reason_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientDownloadReport_Reason_strings[3] = {};
+
+static const char ClientDownloadReport_Reason_names[] =
+  "APPEAL"
+  "FALSE_POSITIVE"
+  "SHARE";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientDownloadReport_Reason_entries[] = {
+  { {ClientDownloadReport_Reason_names + 0, 6}, 2 },
+  { {ClientDownloadReport_Reason_names + 6, 14}, 1 },
+  { {ClientDownloadReport_Reason_names + 20, 5}, 0 },
+};
+
+static const int ClientDownloadReport_Reason_entries_by_number[] = {
+  2, // 0 -> SHARE
+  1, // 1 -> FALSE_POSITIVE
+  0, // 2 -> APPEAL
+};
+
+const std::string& ClientDownloadReport_Reason_Name(
+    ClientDownloadReport_Reason value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ClientDownloadReport_Reason_entries,
+          ClientDownloadReport_Reason_entries_by_number,
+          3, ClientDownloadReport_Reason_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ClientDownloadReport_Reason_entries,
+      ClientDownloadReport_Reason_entries_by_number,
+      3, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ClientDownloadReport_Reason_strings[idx].get();
+}
+bool ClientDownloadReport_Reason_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientDownloadReport_Reason* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ClientDownloadReport_Reason_entries, 3, name, &int_value);
+  if (success) {
+    *value = static_cast<ClientDownloadReport_Reason>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientDownloadReport_Reason ClientDownloadReport::SHARE;
+constexpr ClientDownloadReport_Reason ClientDownloadReport::FALSE_POSITIVE;
+constexpr ClientDownloadReport_Reason ClientDownloadReport::APPEAL;
+constexpr ClientDownloadReport_Reason ClientDownloadReport::Reason_MIN;
+constexpr ClientDownloadReport_Reason ClientDownloadReport::Reason_MAX;
+constexpr int ClientDownloadReport::Reason_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ClientUploadResponse_UploadStatus_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientUploadResponse_UploadStatus_strings[2] = {};
+
+static const char ClientUploadResponse_UploadStatus_names[] =
+  "SUCCESS"
+  "UPLOAD_FAILURE";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientUploadResponse_UploadStatus_entries[] = {
+  { {ClientUploadResponse_UploadStatus_names + 0, 7}, 0 },
+  { {ClientUploadResponse_UploadStatus_names + 7, 14}, 1 },
+};
+
+static const int ClientUploadResponse_UploadStatus_entries_by_number[] = {
+  0, // 0 -> SUCCESS
+  1, // 1 -> UPLOAD_FAILURE
+};
+
+const std::string& ClientUploadResponse_UploadStatus_Name(
+    ClientUploadResponse_UploadStatus value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ClientUploadResponse_UploadStatus_entries,
+          ClientUploadResponse_UploadStatus_entries_by_number,
+          2, ClientUploadResponse_UploadStatus_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ClientUploadResponse_UploadStatus_entries,
+      ClientUploadResponse_UploadStatus_entries_by_number,
+      2, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ClientUploadResponse_UploadStatus_strings[idx].get();
+}
+bool ClientUploadResponse_UploadStatus_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientUploadResponse_UploadStatus* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ClientUploadResponse_UploadStatus_entries, 2, name, &int_value);
+  if (success) {
+    *value = static_cast<ClientUploadResponse_UploadStatus>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientUploadResponse_UploadStatus ClientUploadResponse::SUCCESS;
+constexpr ClientUploadResponse_UploadStatus ClientUploadResponse::UPLOAD_FAILURE;
+constexpr ClientUploadResponse_UploadStatus ClientUploadResponse::UploadStatus_MIN;
+constexpr ClientUploadResponse_UploadStatus ClientUploadResponse::UploadStatus_MAX;
+constexpr int ClientUploadResponse::UploadStatus_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_strings[7] = {};
+
+static const char ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_names[] =
+  "BYPASS_CHANGED"
+  "BYPASS_CLEARED"
+  "CHANGED"
+  "CLEARED"
+  "UNKNOWN"
+  "UNTRUSTED_UNKNOWN_VALUE"
+  "WEAK_LEGACY_OBSOLETE";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_entries[] = {
+  { {ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_names + 0, 14}, 6 },
+  { {ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_names + 14, 14}, 5 },
+  { {ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_names + 28, 7}, 3 },
+  { {ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_names + 35, 7}, 1 },
+  { {ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_names + 42, 7}, 0 },
+  { {ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_names + 49, 23}, 4 },
+  { {ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_names + 72, 20}, 2 },
+};
+
+static const int ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_entries_by_number[] = {
+  4, // 0 -> UNKNOWN
+  3, // 1 -> CLEARED
+  6, // 2 -> WEAK_LEGACY_OBSOLETE
+  2, // 3 -> CHANGED
+  5, // 4 -> UNTRUSTED_UNKNOWN_VALUE
+  1, // 5 -> BYPASS_CLEARED
+  0, // 6 -> BYPASS_CHANGED
+};
+
+const std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_Name(
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_entries,
+          ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_entries_by_number,
+          7, ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_entries,
+      ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_entries_by_number,
+      7, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_strings[idx].get();
+}
+bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_entries, 7, name, &int_value);
+  if (success) {
+    *value = static_cast<ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::UNKNOWN;
+constexpr ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::CLEARED;
+constexpr ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::WEAK_LEGACY_OBSOLETE;
+constexpr ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::CHANGED;
+constexpr ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::UNTRUSTED_UNKNOWN_VALUE;
+constexpr ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::BYPASS_CLEARED;
+constexpr ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::BYPASS_CHANGED;
+constexpr ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ValueState_MIN;
+constexpr ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ValueState_MAX;
+constexpr int ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ValueState_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_strings[2] = {};
+
+static const char ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_names[] =
+  "TYPE_PATTERN"
+  "UNKNOWN";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_entries[] = {
+  { {ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_names + 0, 12}, 3 },
+  { {ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_names + 12, 7}, 0 },
+};
+
+static const int ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_entries_by_number[] = {
+  1, // 0 -> UNKNOWN
+  0, // 3 -> TYPE_PATTERN
+};
+
+const std::string& ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Name(
+    ClientIncidentReport_IncidentData_ResourceRequestIncident_Type value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_entries,
+          ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_entries_by_number,
+          2, ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_entries,
+      ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_entries_by_number,
+      2, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_strings[idx].get();
+}
+bool ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIncidentReport_IncidentData_ResourceRequestIncident_Type* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_entries, 2, name, &int_value);
+  if (success) {
+    *value = static_cast<ClientIncidentReport_IncidentData_ResourceRequestIncident_Type>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident::UNKNOWN;
+constexpr ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident::TYPE_PATTERN;
+constexpr ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident::Type_MIN;
+constexpr ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident::Type_MAX;
+constexpr int ClientIncidentReport_IncidentData_ResourceRequestIncident::Type_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ClientIncidentReport_EnvironmentData_Process_Dll_Feature_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientIncidentReport_EnvironmentData_Process_Dll_Feature_strings[2] = {};
+
+static const char ClientIncidentReport_EnvironmentData_Process_Dll_Feature_names[] =
+  "LSP"
+  "UNKNOWN";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientIncidentReport_EnvironmentData_Process_Dll_Feature_entries[] = {
+  { {ClientIncidentReport_EnvironmentData_Process_Dll_Feature_names + 0, 3}, 1 },
+  { {ClientIncidentReport_EnvironmentData_Process_Dll_Feature_names + 3, 7}, 0 },
+};
+
+static const int ClientIncidentReport_EnvironmentData_Process_Dll_Feature_entries_by_number[] = {
+  1, // 0 -> UNKNOWN
+  0, // 1 -> LSP
+};
+
+const std::string& ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Name(
+    ClientIncidentReport_EnvironmentData_Process_Dll_Feature value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ClientIncidentReport_EnvironmentData_Process_Dll_Feature_entries,
+          ClientIncidentReport_EnvironmentData_Process_Dll_Feature_entries_by_number,
+          2, ClientIncidentReport_EnvironmentData_Process_Dll_Feature_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ClientIncidentReport_EnvironmentData_Process_Dll_Feature_entries,
+      ClientIncidentReport_EnvironmentData_Process_Dll_Feature_entries_by_number,
+      2, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ClientIncidentReport_EnvironmentData_Process_Dll_Feature_strings[idx].get();
+}
+bool ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIncidentReport_EnvironmentData_Process_Dll_Feature* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ClientIncidentReport_EnvironmentData_Process_Dll_Feature_entries, 2, name, &int_value);
+  if (success) {
+    *value = static_cast<ClientIncidentReport_EnvironmentData_Process_Dll_Feature>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll::UNKNOWN;
+constexpr ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll::LSP;
+constexpr ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll::Feature_MIN;
+constexpr ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll::Feature_MAX;
+constexpr int ClientIncidentReport_EnvironmentData_Process_Dll::Feature_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_strings[4] = {};
+
+static const char ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_names[] =
+  "MODULE_STATE_MODIFIED"
+  "MODULE_STATE_UNKNOWN"
+  "MODULE_STATE_UNMODIFIED"
+  "UNKNOWN";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_entries[] = {
+  { {ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_names + 0, 21}, 3 },
+  { {ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_names + 21, 20}, 1 },
+  { {ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_names + 41, 23}, 2 },
+  { {ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_names + 64, 7}, 0 },
+};
+
+static const int ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_entries_by_number[] = {
+  3, // 0 -> UNKNOWN
+  1, // 1 -> MODULE_STATE_UNKNOWN
+  2, // 2 -> MODULE_STATE_UNMODIFIED
+  0, // 3 -> MODULE_STATE_MODIFIED
+};
+
+const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_Name(
+    ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_entries,
+          ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_entries_by_number,
+          4, ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_entries,
+      ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_entries_by_number,
+      4, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_strings[idx].get();
+}
+bool ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_entries, 4, name, &int_value);
+  if (success) {
+    *value = static_cast<ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::UNKNOWN;
+constexpr ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::MODULE_STATE_UNKNOWN;
+constexpr ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::MODULE_STATE_UNMODIFIED;
+constexpr ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::MODULE_STATE_MODIFIED;
+constexpr ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::ModifiedState_MIN;
+constexpr ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::ModifiedState_MAX;
+constexpr int ClientIncidentReport_EnvironmentData_Process_ModuleState::ModifiedState_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ClientIncidentReport_EnvironmentData_Process_Channel_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientIncidentReport_EnvironmentData_Process_Channel_strings[5] = {};
+
+static const char ClientIncidentReport_EnvironmentData_Process_Channel_names[] =
+  "CHANNEL_BETA"
+  "CHANNEL_CANARY"
+  "CHANNEL_DEV"
+  "CHANNEL_STABLE"
+  "CHANNEL_UNKNOWN";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientIncidentReport_EnvironmentData_Process_Channel_entries[] = {
+  { {ClientIncidentReport_EnvironmentData_Process_Channel_names + 0, 12}, 3 },
+  { {ClientIncidentReport_EnvironmentData_Process_Channel_names + 12, 14}, 1 },
+  { {ClientIncidentReport_EnvironmentData_Process_Channel_names + 26, 11}, 2 },
+  { {ClientIncidentReport_EnvironmentData_Process_Channel_names + 37, 14}, 4 },
+  { {ClientIncidentReport_EnvironmentData_Process_Channel_names + 51, 15}, 0 },
+};
+
+static const int ClientIncidentReport_EnvironmentData_Process_Channel_entries_by_number[] = {
+  4, // 0 -> CHANNEL_UNKNOWN
+  1, // 1 -> CHANNEL_CANARY
+  2, // 2 -> CHANNEL_DEV
+  0, // 3 -> CHANNEL_BETA
+  3, // 4 -> CHANNEL_STABLE
+};
+
+const std::string& ClientIncidentReport_EnvironmentData_Process_Channel_Name(
+    ClientIncidentReport_EnvironmentData_Process_Channel value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ClientIncidentReport_EnvironmentData_Process_Channel_entries,
+          ClientIncidentReport_EnvironmentData_Process_Channel_entries_by_number,
+          5, ClientIncidentReport_EnvironmentData_Process_Channel_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ClientIncidentReport_EnvironmentData_Process_Channel_entries,
+      ClientIncidentReport_EnvironmentData_Process_Channel_entries_by_number,
+      5, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ClientIncidentReport_EnvironmentData_Process_Channel_strings[idx].get();
+}
+bool ClientIncidentReport_EnvironmentData_Process_Channel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIncidentReport_EnvironmentData_Process_Channel* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ClientIncidentReport_EnvironmentData_Process_Channel_entries, 5, name, &int_value);
+  if (success) {
+    *value = static_cast<ClientIncidentReport_EnvironmentData_Process_Channel>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::CHANNEL_UNKNOWN;
+constexpr ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::CHANNEL_CANARY;
+constexpr ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::CHANNEL_DEV;
+constexpr ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::CHANNEL_BETA;
+constexpr ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::CHANNEL_STABLE;
+constexpr ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::Channel_MIN;
+constexpr ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::Channel_MAX;
+constexpr int ClientIncidentReport_EnvironmentData_Process::Channel_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_strings[6] = {};
+
+static const char ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_names[] =
+  "STATE_BLACKLISTED"
+  "STATE_BLOCKED"
+  "STATE_DISABLED"
+  "STATE_ENABLED"
+  "STATE_TERMINATED"
+  "STATE_UNKNOWN";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_entries[] = {
+  { {ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_names + 0, 17}, 3 },
+  { {ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_names + 17, 13}, 4 },
+  { {ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_names + 30, 14}, 2 },
+  { {ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_names + 44, 13}, 1 },
+  { {ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_names + 57, 16}, 5 },
+  { {ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_names + 73, 13}, 0 },
+};
+
+static const int ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_entries_by_number[] = {
+  5, // 0 -> STATE_UNKNOWN
+  3, // 1 -> STATE_ENABLED
+  2, // 2 -> STATE_DISABLED
+  0, // 3 -> STATE_BLACKLISTED
+  1, // 4 -> STATE_BLOCKED
+  4, // 5 -> STATE_TERMINATED
+};
+
+const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_Name(
+    ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_entries,
+          ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_entries_by_number,
+          6, ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_entries,
+      ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_entries_by_number,
+      6, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_strings[idx].get();
+}
+bool ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_entries, 6, name, &int_value);
+  if (success) {
+    *value = static_cast<ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::STATE_UNKNOWN;
+constexpr ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::STATE_ENABLED;
+constexpr ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::STATE_DISABLED;
+constexpr ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::STATE_BLACKLISTED;
+constexpr ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::STATE_BLOCKED;
+constexpr ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::STATE_TERMINATED;
+constexpr ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::ExtensionState_MIN;
+constexpr ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::ExtensionState_MAX;
+constexpr int ClientIncidentReport_ExtensionData_ExtensionInfo::ExtensionState_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ClientSafeBrowsingReportRequest_ReportType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 10:
+    case 12:
+    case 13:
+    case 14:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientSafeBrowsingReportRequest_ReportType_strings[12] = {};
+
+static const char ClientSafeBrowsingReportRequest_ReportType_names[] =
+  "AD_SAMPLE"
+  "DANGEROUS_DOWNLOAD_BY_API"
+  "DANGEROUS_DOWNLOAD_OPENED"
+  "DANGEROUS_DOWNLOAD_RECOVERY"
+  "DANGEROUS_DOWNLOAD_WARNING"
+  "UNKNOWN"
+  "URL_CLIENT_SIDE_MALWARE"
+  "URL_CLIENT_SIDE_PHISHING"
+  "URL_MALWARE"
+  "URL_PASSWORD_PROTECTION_PHISHING"
+  "URL_PHISHING"
+  "URL_UNWANTED";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientSafeBrowsingReportRequest_ReportType_entries[] = {
+  { {ClientSafeBrowsingReportRequest_ReportType_names + 0, 9}, 14 },
+  { {ClientSafeBrowsingReportRequest_ReportType_names + 9, 25}, 10 },
+  { {ClientSafeBrowsingReportRequest_ReportType_names + 34, 25}, 13 },
+  { {ClientSafeBrowsingReportRequest_ReportType_names + 59, 27}, 6 },
+  { {ClientSafeBrowsingReportRequest_ReportType_names + 86, 26}, 7 },
+  { {ClientSafeBrowsingReportRequest_ReportType_names + 112, 7}, 0 },
+  { {ClientSafeBrowsingReportRequest_ReportType_names + 119, 23}, 5 },
+  { {ClientSafeBrowsingReportRequest_ReportType_names + 142, 24}, 4 },
+  { {ClientSafeBrowsingReportRequest_ReportType_names + 166, 11}, 2 },
+  { {ClientSafeBrowsingReportRequest_ReportType_names + 177, 32}, 12 },
+  { {ClientSafeBrowsingReportRequest_ReportType_names + 209, 12}, 1 },
+  { {ClientSafeBrowsingReportRequest_ReportType_names + 221, 12}, 3 },
+};
+
+static const int ClientSafeBrowsingReportRequest_ReportType_entries_by_number[] = {
+  5, // 0 -> UNKNOWN
+  10, // 1 -> URL_PHISHING
+  8, // 2 -> URL_MALWARE
+  11, // 3 -> URL_UNWANTED
+  7, // 4 -> URL_CLIENT_SIDE_PHISHING
+  6, // 5 -> URL_CLIENT_SIDE_MALWARE
+  3, // 6 -> DANGEROUS_DOWNLOAD_RECOVERY
+  4, // 7 -> DANGEROUS_DOWNLOAD_WARNING
+  1, // 10 -> DANGEROUS_DOWNLOAD_BY_API
+  9, // 12 -> URL_PASSWORD_PROTECTION_PHISHING
+  2, // 13 -> DANGEROUS_DOWNLOAD_OPENED
+  0, // 14 -> AD_SAMPLE
+};
+
+const std::string& ClientSafeBrowsingReportRequest_ReportType_Name(
+    ClientSafeBrowsingReportRequest_ReportType value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ClientSafeBrowsingReportRequest_ReportType_entries,
+          ClientSafeBrowsingReportRequest_ReportType_entries_by_number,
+          12, ClientSafeBrowsingReportRequest_ReportType_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ClientSafeBrowsingReportRequest_ReportType_entries,
+      ClientSafeBrowsingReportRequest_ReportType_entries_by_number,
+      12, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ClientSafeBrowsingReportRequest_ReportType_strings[idx].get();
+}
+bool ClientSafeBrowsingReportRequest_ReportType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientSafeBrowsingReportRequest_ReportType* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ClientSafeBrowsingReportRequest_ReportType_entries, 12, name, &int_value);
+  if (success) {
+    *value = static_cast<ClientSafeBrowsingReportRequest_ReportType>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::UNKNOWN;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::URL_PHISHING;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::URL_MALWARE;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::URL_UNWANTED;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::URL_CLIENT_SIDE_PHISHING;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::URL_CLIENT_SIDE_MALWARE;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::DANGEROUS_DOWNLOAD_RECOVERY;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::DANGEROUS_DOWNLOAD_WARNING;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::DANGEROUS_DOWNLOAD_BY_API;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::URL_PASSWORD_PROTECTION_PHISHING;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::DANGEROUS_DOWNLOAD_OPENED;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::AD_SAMPLE;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::ReportType_MIN;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::ReportType_MAX;
+constexpr int ClientSafeBrowsingReportRequest::ReportType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+bool ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_strings[5] = {};
+
+static const char ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_names[] =
+  "ANDROID_SAFETYNET"
+  "FLYWHEEL"
+  "PVER3_NATIVE"
+  "PVER4_NATIVE"
+  "SAFE_BROWSING_URL_API_TYPE_UNSPECIFIED";
+
+static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_entries[] = {
+  { {ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_names + 0, 17}, 3 },
+  { {ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_names + 17, 8}, 4 },
+  { {ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_names + 25, 12}, 1 },
+  { {ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_names + 37, 12}, 2 },
+  { {ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_names + 49, 38}, 0 },
+};
+
+static const int ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_entries_by_number[] = {
+  4, // 0 -> SAFE_BROWSING_URL_API_TYPE_UNSPECIFIED
+  2, // 1 -> PVER3_NATIVE
+  3, // 2 -> PVER4_NATIVE
+  0, // 3 -> ANDROID_SAFETYNET
+  1, // 4 -> FLYWHEEL
+};
+
+const std::string& ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_Name(
+    ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType value) {
+  static const bool dummy =
+      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
+          ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_entries,
+          ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_entries_by_number,
+          5, ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_strings);
+  (void) dummy;
+  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
+      ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_entries,
+      ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_entries_by_number,
+      5, value);
+  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
+                     ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_strings[idx].get();
+}
+bool ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType* value) {
+  int int_value;
+  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
+      ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_entries, 5, name, &int_value);
+  if (success) {
+    *value = static_cast<ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType>(int_value);
+  }
+  return success;
+}
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType ClientSafeBrowsingReportRequest::SAFE_BROWSING_URL_API_TYPE_UNSPECIFIED;
+constexpr ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType ClientSafeBrowsingReportRequest::PVER3_NATIVE;
+constexpr ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType ClientSafeBrowsingReportRequest::PVER4_NATIVE;
+constexpr ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType ClientSafeBrowsingReportRequest::ANDROID_SAFETYNET;
+constexpr ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType ClientSafeBrowsingReportRequest::FLYWHEEL;
+constexpr ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType ClientSafeBrowsingReportRequest::SafeBrowsingUrlApiType_MIN;
+constexpr ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType ClientSafeBrowsingReportRequest::SafeBrowsingUrlApiType_MAX;
+constexpr int ClientSafeBrowsingReportRequest::SafeBrowsingUrlApiType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+
+// ===================================================================
+
+class ChromeUserPopulation::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ChromeUserPopulation>()._impl_._has_bits_);
+  static void set_has_user_population(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_is_history_sync_enabled(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ChromeUserPopulation::ChromeUserPopulation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ChromeUserPopulation)
+}
+ChromeUserPopulation::ChromeUserPopulation(const ChromeUserPopulation& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ChromeUserPopulation* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.finch_active_groups_){from._impl_.finch_active_groups_}
+    , decltype(_impl_.user_population_){}
+    , decltype(_impl_.is_history_sync_enabled_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::memcpy(&_impl_.user_population_, &from._impl_.user_population_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.is_history_sync_enabled_) -
+    reinterpret_cast<char*>(&_impl_.user_population_)) + sizeof(_impl_.is_history_sync_enabled_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ChromeUserPopulation)
+}
+
+inline void ChromeUserPopulation::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.finch_active_groups_){arena}
+    , decltype(_impl_.user_population_){0}
+    , decltype(_impl_.is_history_sync_enabled_){false}
+  };
+}
+
+ChromeUserPopulation::~ChromeUserPopulation() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ChromeUserPopulation)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ChromeUserPopulation::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.finch_active_groups_.~RepeatedPtrField();
+}
+
+void ChromeUserPopulation::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ChromeUserPopulation::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ChromeUserPopulation)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.finch_active_groups_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    ::memset(&_impl_.user_population_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.is_history_sync_enabled_) -
+        reinterpret_cast<char*>(&_impl_.user_population_)) + sizeof(_impl_.is_history_sync_enabled_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ChromeUserPopulation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .safe_browsing.ChromeUserPopulation.UserPopulation user_population = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ChromeUserPopulation_UserPopulation_IsValid(val))) {
+            _internal_set_user_population(static_cast<::safe_browsing::ChromeUserPopulation_UserPopulation>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool is_history_sync_enabled = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_is_history_sync_enabled(&has_bits);
+          _impl_.is_history_sync_enabled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string finch_active_groups = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_finch_active_groups();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ChromeUserPopulation::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ChromeUserPopulation)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .safe_browsing.ChromeUserPopulation.UserPopulation user_population = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_user_population(), target);
+  }
+
+  // optional bool is_history_sync_enabled = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_is_history_sync_enabled(), target);
+  }
+
+  // repeated string finch_active_groups = 4;
+  for (int i = 0, n = this->_internal_finch_active_groups_size(); i < n; i++) {
+    const auto& s = this->_internal_finch_active_groups(i);
+    target = stream->WriteString(4, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ChromeUserPopulation)
+  return target;
+}
+
+size_t ChromeUserPopulation::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ChromeUserPopulation)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string finch_active_groups = 4;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.finch_active_groups_.size());
+  for (int i = 0, n = _impl_.finch_active_groups_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.finch_active_groups_.Get(i));
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .safe_browsing.ChromeUserPopulation.UserPopulation user_population = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_user_population());
+    }
+
+    // optional bool is_history_sync_enabled = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ChromeUserPopulation::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ChromeUserPopulation*>(
+      &from));
+}
+
+void ChromeUserPopulation::MergeFrom(const ChromeUserPopulation& from) {
+  ChromeUserPopulation* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ChromeUserPopulation)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.finch_active_groups_.MergeFrom(from._impl_.finch_active_groups_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.user_population_ = from._impl_.user_population_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.is_history_sync_enabled_ = from._impl_.is_history_sync_enabled_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ChromeUserPopulation::CopyFrom(const ChromeUserPopulation& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ChromeUserPopulation)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChromeUserPopulation::IsInitialized() const {
+  return true;
+}
+
+void ChromeUserPopulation::InternalSwap(ChromeUserPopulation* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.finch_active_groups_.InternalSwap(&other->_impl_.finch_active_groups_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ChromeUserPopulation, _impl_.is_history_sync_enabled_)
+      + sizeof(ChromeUserPopulation::_impl_.is_history_sync_enabled_)
+      - PROTOBUF_FIELD_OFFSET(ChromeUserPopulation, _impl_.user_population_)>(
+          reinterpret_cast<char*>(&_impl_.user_population_),
+          reinterpret_cast<char*>(&other->_impl_.user_population_));
+}
+
+std::string ChromeUserPopulation::GetTypeName() const {
+  return "safe_browsing.ChromeUserPopulation";
+}
+
+
+// ===================================================================
+
+class ClientPhishingRequest_Feature::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientPhishingRequest_Feature>()._impl_._has_bits_);
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_value(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
+  }
+};
+
+ClientPhishingRequest_Feature::ClientPhishingRequest_Feature(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientPhishingRequest.Feature)
+}
+ClientPhishingRequest_Feature::ClientPhishingRequest_Feature(const ClientPhishingRequest_Feature& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientPhishingRequest_Feature* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.value_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.value_ = from._impl_.value_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientPhishingRequest.Feature)
+}
+
+inline void ClientPhishingRequest_Feature::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.value_){0}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientPhishingRequest_Feature::~ClientPhishingRequest_Feature() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientPhishingRequest.Feature)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientPhishingRequest_Feature::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+}
+
+void ClientPhishingRequest_Feature::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientPhishingRequest_Feature::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientPhishingRequest.Feature)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.name_.ClearNonDefaultToEmpty();
+  }
+  _impl_.value_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientPhishingRequest_Feature::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // required double value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
+          _Internal::set_has_value(&has_bits);
+          _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientPhishingRequest_Feature::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientPhishingRequest.Feature)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required string name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // required double value = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_value(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientPhishingRequest.Feature)
+  return target;
+}
+
+size_t ClientPhishingRequest_Feature::RequiredFieldsByteSizeFallback() const {
+// @@protoc_insertion_point(required_fields_byte_size_fallback_start:safe_browsing.ClientPhishingRequest.Feature)
+  size_t total_size = 0;
+
+  if (_internal_has_name()) {
+    // required string name = 1;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  if (_internal_has_value()) {
+    // required double value = 2;
+    total_size += 1 + 8;
+  }
+
+  return total_size;
+}
+size_t ClientPhishingRequest_Feature::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientPhishingRequest.Feature)
+  size_t total_size = 0;
+
+  if (((_impl_._has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
+    // required string name = 1;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+
+    // required double value = 2;
+    total_size += 1 + 8;
+
+  } else {
+    total_size += RequiredFieldsByteSizeFallback();
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientPhishingRequest_Feature::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientPhishingRequest_Feature*>(
+      &from));
+}
+
+void ClientPhishingRequest_Feature::MergeFrom(const ClientPhishingRequest_Feature& from) {
+  ClientPhishingRequest_Feature* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientPhishingRequest.Feature)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.value_ = from._impl_.value_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientPhishingRequest_Feature::CopyFrom(const ClientPhishingRequest_Feature& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientPhishingRequest.Feature)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientPhishingRequest_Feature::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  return true;
+}
+
+void ClientPhishingRequest_Feature::InternalSwap(ClientPhishingRequest_Feature* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  swap(_impl_.value_, other->_impl_.value_);
+}
+
+std::string ClientPhishingRequest_Feature::GetTypeName() const {
+  return "safe_browsing.ClientPhishingRequest.Feature";
+}
+
+
+// ===================================================================
+
+class ClientPhishingRequest::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientPhishingRequest>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_obsolete_hash_prefix(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_client_score(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_is_phishing(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_model_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_obsolete_referrer_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_model_filename(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::safe_browsing::ChromeUserPopulation& population(const ClientPhishingRequest* msg);
+  static void set_has_population(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000020) ^ 0x00000020) != 0;
+  }
+};
+
+const ::safe_browsing::ChromeUserPopulation&
+ClientPhishingRequest::_Internal::population(const ClientPhishingRequest* msg) {
+  return *msg->_impl_.population_;
+}
+ClientPhishingRequest::ClientPhishingRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientPhishingRequest)
+}
+ClientPhishingRequest::ClientPhishingRequest(const ClientPhishingRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientPhishingRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.feature_map_){from._impl_.feature_map_}
+    , decltype(_impl_.non_model_feature_map_){from._impl_.non_model_feature_map_}
+    , decltype(_impl_.shingle_hashes_){from._impl_.shingle_hashes_}
+    , /*decltype(_impl_._shingle_hashes_cached_byte_size_)*/{0}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.obsolete_referrer_url_){}
+    , decltype(_impl_.obsolete_hash_prefix_){}
+    , decltype(_impl_.model_filename_){}
+    , decltype(_impl_.population_){nullptr}
+    , decltype(_impl_.client_score_){}
+    , decltype(_impl_.is_phishing_){}
+    , decltype(_impl_.model_version_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.obsolete_referrer_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.obsolete_referrer_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_obsolete_referrer_url()) {
+    _this->_impl_.obsolete_referrer_url_.Set(from._internal_obsolete_referrer_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.obsolete_hash_prefix_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.obsolete_hash_prefix_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_obsolete_hash_prefix()) {
+    _this->_impl_.obsolete_hash_prefix_.Set(from._internal_obsolete_hash_prefix(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.model_filename_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.model_filename_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_model_filename()) {
+    _this->_impl_.model_filename_.Set(from._internal_model_filename(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_population()) {
+    _this->_impl_.population_ = new ::safe_browsing::ChromeUserPopulation(*from._impl_.population_);
+  }
+  ::memcpy(&_impl_.client_score_, &from._impl_.client_score_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.model_version_) -
+    reinterpret_cast<char*>(&_impl_.client_score_)) + sizeof(_impl_.model_version_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientPhishingRequest)
+}
+
+inline void ClientPhishingRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.feature_map_){arena}
+    , decltype(_impl_.non_model_feature_map_){arena}
+    , decltype(_impl_.shingle_hashes_){arena}
+    , /*decltype(_impl_._shingle_hashes_cached_byte_size_)*/{0}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.obsolete_referrer_url_){}
+    , decltype(_impl_.obsolete_hash_prefix_){}
+    , decltype(_impl_.model_filename_){}
+    , decltype(_impl_.population_){nullptr}
+    , decltype(_impl_.client_score_){0}
+    , decltype(_impl_.is_phishing_){false}
+    , decltype(_impl_.model_version_){0}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.obsolete_referrer_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.obsolete_referrer_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.obsolete_hash_prefix_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.obsolete_hash_prefix_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.model_filename_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.model_filename_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientPhishingRequest::~ClientPhishingRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientPhishingRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientPhishingRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.feature_map_.~RepeatedPtrField();
+  _impl_.non_model_feature_map_.~RepeatedPtrField();
+  _impl_.shingle_hashes_.~RepeatedField();
+  _impl_.url_.Destroy();
+  _impl_.obsolete_referrer_url_.Destroy();
+  _impl_.obsolete_hash_prefix_.Destroy();
+  _impl_.model_filename_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.population_;
+}
+
+void ClientPhishingRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientPhishingRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientPhishingRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.feature_map_.Clear();
+  _impl_.non_model_feature_map_.Clear();
+  _impl_.shingle_hashes_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.obsolete_referrer_url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.obsolete_hash_prefix_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.model_filename_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.population_ != nullptr);
+      _impl_.population_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x000000e0u) {
+    ::memset(&_impl_.client_score_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.model_version_) -
+        reinterpret_cast<char*>(&_impl_.client_score_)) + sizeof(_impl_.model_version_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientPhishingRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // required float client_score = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 21)) {
+          _Internal::set_has_client_score(&has_bits);
+          _impl_.client_score_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool is_phishing = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_is_phishing(&has_bits);
+          _impl_.is_phishing_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_feature_map(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 model_version = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_model_version(&has_bits);
+          _impl_.model_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientPhishingRequest.Feature non_model_feature_map = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_non_model_feature_map(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string OBSOLETE_referrer_url = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_obsolete_referrer_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes OBSOLETE_hash_prefix = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          auto str = _internal_mutable_obsolete_hash_prefix();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated uint32 shingle_hashes = 12 [packed = true];
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_shingle_hashes(), ptr, ctx);
+          CHK_(ptr);
+        } else if (static_cast<uint8_t>(tag) == 96) {
+          _internal_add_shingle_hashes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string model_filename = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          auto str = _internal_mutable_model_filename();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ChromeUserPopulation population = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
+          ptr = ctx->ParseMessage(_internal_mutable_population(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientPhishingRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientPhishingRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // required float client_score = 2;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteFloatToArray(2, this->_internal_client_score(), target);
+  }
+
+  // optional bool is_phishing = 4;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_is_phishing(), target);
+  }
+
+  // repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_feature_map_size()); i < n; i++) {
+    const auto& repfield = this->_internal_feature_map(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional int32 model_version = 6;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_model_version(), target);
+  }
+
+  // repeated .safe_browsing.ClientPhishingRequest.Feature non_model_feature_map = 8;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_non_model_feature_map_size()); i < n; i++) {
+    const auto& repfield = this->_internal_non_model_feature_map(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(8, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional string OBSOLETE_referrer_url = 9;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        9, this->_internal_obsolete_referrer_url(), target);
+  }
+
+  // optional bytes OBSOLETE_hash_prefix = 10;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        10, this->_internal_obsolete_hash_prefix(), target);
+  }
+
+  // repeated uint32 shingle_hashes = 12 [packed = true];
+  {
+    int byte_size = _impl_._shingle_hashes_cached_byte_size_.load(std::memory_order_relaxed);
+    if (byte_size > 0) {
+      target = stream->WriteUInt32Packed(
+          12, _internal_shingle_hashes(), byte_size, target);
+    }
+  }
+
+  // optional string model_filename = 13;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteStringMaybeAliased(
+        13, this->_internal_model_filename(), target);
+  }
+
+  // optional .safe_browsing.ChromeUserPopulation population = 14;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(14, _Internal::population(this),
+        _Internal::population(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientPhishingRequest)
+  return target;
+}
+
+size_t ClientPhishingRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientPhishingRequest)
+  size_t total_size = 0;
+
+  // required float client_score = 2;
+  if (_internal_has_client_score()) {
+    total_size += 1 + 4;
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5;
+  total_size += 1UL * this->_internal_feature_map_size();
+  for (const auto& msg : this->_impl_.feature_map_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .safe_browsing.ClientPhishingRequest.Feature non_model_feature_map = 8;
+  total_size += 1UL * this->_internal_non_model_feature_map_size();
+  for (const auto& msg : this->_impl_.non_model_feature_map_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated uint32 shingle_hashes = 12 [packed = true];
+  {
+    size_t data_size = ::_pbi::WireFormatLite::
+      UInt32Size(this->_impl_.shingle_hashes_);
+    if (data_size > 0) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::Int32Size(static_cast<int32_t>(data_size));
+    }
+    int cached_size = ::_pbi::ToCachedSize(data_size);
+    _impl_._shingle_hashes_cached_byte_size_.store(cached_size,
+                                    std::memory_order_relaxed);
+    total_size += data_size;
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional string url = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional string OBSOLETE_referrer_url = 9;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_obsolete_referrer_url());
+    }
+
+    // optional bytes OBSOLETE_hash_prefix = 10;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_obsolete_hash_prefix());
+    }
+
+    // optional string model_filename = 13;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_model_filename());
+    }
+
+    // optional .safe_browsing.ChromeUserPopulation population = 14;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.population_);
+    }
+
+  }
+  if (cached_has_bits & 0x000000c0u) {
+    // optional bool is_phishing = 4;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 + 1;
+    }
+
+    // optional int32 model_version = 6;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_model_version());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientPhishingRequest::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientPhishingRequest*>(
+      &from));
+}
+
+void ClientPhishingRequest::MergeFrom(const ClientPhishingRequest& from) {
+  ClientPhishingRequest* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientPhishingRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.feature_map_.MergeFrom(from._impl_.feature_map_);
+  _this->_impl_.non_model_feature_map_.MergeFrom(from._impl_.non_model_feature_map_);
+  _this->_impl_.shingle_hashes_.MergeFrom(from._impl_.shingle_hashes_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_obsolete_referrer_url(from._internal_obsolete_referrer_url());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_obsolete_hash_prefix(from._internal_obsolete_hash_prefix());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_model_filename(from._internal_model_filename());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(
+          from._internal_population());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.client_score_ = from._impl_.client_score_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.is_phishing_ = from._impl_.is_phishing_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.model_version_ = from._impl_.model_version_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientPhishingRequest::CopyFrom(const ClientPhishingRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientPhishingRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientPhishingRequest::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.feature_map_))
+    return false;
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.non_model_feature_map_))
+    return false;
+  return true;
+}
+
+void ClientPhishingRequest::InternalSwap(ClientPhishingRequest* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.feature_map_.InternalSwap(&other->_impl_.feature_map_);
+  _impl_.non_model_feature_map_.InternalSwap(&other->_impl_.non_model_feature_map_);
+  _impl_.shingle_hashes_.InternalSwap(&other->_impl_.shingle_hashes_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.obsolete_referrer_url_, lhs_arena,
+      &other->_impl_.obsolete_referrer_url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.obsolete_hash_prefix_, lhs_arena,
+      &other->_impl_.obsolete_hash_prefix_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.model_filename_, lhs_arena,
+      &other->_impl_.model_filename_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientPhishingRequest, _impl_.model_version_)
+      + sizeof(ClientPhishingRequest::_impl_.model_version_)
+      - PROTOBUF_FIELD_OFFSET(ClientPhishingRequest, _impl_.population_)>(
+          reinterpret_cast<char*>(&_impl_.population_),
+          reinterpret_cast<char*>(&other->_impl_.population_));
+}
+
+std::string ClientPhishingRequest::GetTypeName() const {
+  return "safe_browsing.ClientPhishingRequest";
+}
+
+
+// ===================================================================
+
+class ClientPhishingResponse::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientPhishingResponse>()._impl_._has_bits_);
+  static void set_has_phishy(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
+  }
+};
+
+ClientPhishingResponse::ClientPhishingResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientPhishingResponse)
+}
+ClientPhishingResponse::ClientPhishingResponse(const ClientPhishingResponse& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientPhishingResponse* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.obsolete_whitelist_expression_){from._impl_.obsolete_whitelist_expression_}
+    , decltype(_impl_.phishy_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _this->_impl_.phishy_ = from._impl_.phishy_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientPhishingResponse)
+}
+
+inline void ClientPhishingResponse::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.obsolete_whitelist_expression_){arena}
+    , decltype(_impl_.phishy_){false}
+  };
+}
+
+ClientPhishingResponse::~ClientPhishingResponse() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientPhishingResponse)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientPhishingResponse::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.obsolete_whitelist_expression_.~RepeatedPtrField();
+}
+
+void ClientPhishingResponse::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientPhishingResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientPhishingResponse)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.obsolete_whitelist_expression_.Clear();
+  _impl_.phishy_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientPhishingResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required bool phishy = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_phishy(&has_bits);
+          _impl_.phishy_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string OBSOLETE_whitelist_expression = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_obsolete_whitelist_expression();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientPhishingResponse::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientPhishingResponse)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required bool phishy = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_phishy(), target);
+  }
+
+  // repeated string OBSOLETE_whitelist_expression = 2;
+  for (int i = 0, n = this->_internal_obsolete_whitelist_expression_size(); i < n; i++) {
+    const auto& s = this->_internal_obsolete_whitelist_expression(i);
+    target = stream->WriteString(2, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientPhishingResponse)
+  return target;
+}
+
+size_t ClientPhishingResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientPhishingResponse)
+  size_t total_size = 0;
+
+  // required bool phishy = 1;
+  if (_internal_has_phishy()) {
+    total_size += 1 + 1;
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string OBSOLETE_whitelist_expression = 2;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.obsolete_whitelist_expression_.size());
+  for (int i = 0, n = _impl_.obsolete_whitelist_expression_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.obsolete_whitelist_expression_.Get(i));
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientPhishingResponse::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientPhishingResponse*>(
+      &from));
+}
+
+void ClientPhishingResponse::MergeFrom(const ClientPhishingResponse& from) {
+  ClientPhishingResponse* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientPhishingResponse)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.obsolete_whitelist_expression_.MergeFrom(from._impl_.obsolete_whitelist_expression_);
+  if (from._internal_has_phishy()) {
+    _this->_internal_set_phishy(from._internal_phishy());
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientPhishingResponse::CopyFrom(const ClientPhishingResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientPhishingResponse)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientPhishingResponse::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  return true;
+}
+
+void ClientPhishingResponse::InternalSwap(ClientPhishingResponse* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.obsolete_whitelist_expression_.InternalSwap(&other->_impl_.obsolete_whitelist_expression_);
+  swap(_impl_.phishy_, other->_impl_.phishy_);
+}
+
+std::string ClientPhishingResponse::GetTypeName() const {
+  return "safe_browsing.ClientPhishingResponse";
+}
+
+
+// ===================================================================
+
+class ClientMalwareRequest_UrlInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientMalwareRequest_UrlInfo>()._impl_._has_bits_);
+  static void set_has_ip(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_method(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_referrer(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_resource_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
+  }
+};
+
+ClientMalwareRequest_UrlInfo::ClientMalwareRequest_UrlInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientMalwareRequest.UrlInfo)
+}
+ClientMalwareRequest_UrlInfo::ClientMalwareRequest_UrlInfo(const ClientMalwareRequest_UrlInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientMalwareRequest_UrlInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.ip_){}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.method_){}
+    , decltype(_impl_.referrer_){}
+    , decltype(_impl_.resource_type_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.ip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.ip_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_ip()) {
+    _this->_impl_.ip_.Set(from._internal_ip(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.method_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.method_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_method()) {
+    _this->_impl_.method_.Set(from._internal_method(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.referrer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.referrer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_referrer()) {
+    _this->_impl_.referrer_.Set(from._internal_referrer(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.resource_type_ = from._impl_.resource_type_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientMalwareRequest.UrlInfo)
+}
+
+inline void ClientMalwareRequest_UrlInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.ip_){}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.method_){}
+    , decltype(_impl_.referrer_){}
+    , decltype(_impl_.resource_type_){0}
+  };
+  _impl_.ip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.ip_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.method_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.method_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.referrer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.referrer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientMalwareRequest_UrlInfo::~ClientMalwareRequest_UrlInfo() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientMalwareRequest.UrlInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientMalwareRequest_UrlInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.ip_.Destroy();
+  _impl_.url_.Destroy();
+  _impl_.method_.Destroy();
+  _impl_.referrer_.Destroy();
+}
+
+void ClientMalwareRequest_UrlInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientMalwareRequest_UrlInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientMalwareRequest.UrlInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.ip_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.method_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.referrer_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.resource_type_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientMalwareRequest_UrlInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required string ip = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_ip();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // required string url = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string method = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_method();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string referrer = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_referrer();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 resource_type = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_resource_type(&has_bits);
+          _impl_.resource_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientMalwareRequest_UrlInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientMalwareRequest.UrlInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required string ip = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_ip(), target);
+  }
+
+  // required string url = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_url(), target);
+  }
+
+  // optional string method = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_method(), target);
+  }
+
+  // optional string referrer = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_referrer(), target);
+  }
+
+  // optional int32 resource_type = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_resource_type(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientMalwareRequest.UrlInfo)
+  return target;
+}
+
+size_t ClientMalwareRequest_UrlInfo::RequiredFieldsByteSizeFallback() const {
+// @@protoc_insertion_point(required_fields_byte_size_fallback_start:safe_browsing.ClientMalwareRequest.UrlInfo)
+  size_t total_size = 0;
+
+  if (_internal_has_ip()) {
+    // required string ip = 1;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_ip());
+  }
+
+  if (_internal_has_url()) {
+    // required string url = 2;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_url());
+  }
+
+  return total_size;
+}
+size_t ClientMalwareRequest_UrlInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientMalwareRequest.UrlInfo)
+  size_t total_size = 0;
+
+  if (((_impl_._has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
+    // required string ip = 1;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_ip());
+
+    // required string url = 2;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_url());
+
+  } else {
+    total_size += RequiredFieldsByteSizeFallback();
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001cu) {
+    // optional string method = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_method());
+    }
+
+    // optional string referrer = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_referrer());
+    }
+
+    // optional int32 resource_type = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_resource_type());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientMalwareRequest_UrlInfo::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientMalwareRequest_UrlInfo*>(
+      &from));
+}
+
+void ClientMalwareRequest_UrlInfo::MergeFrom(const ClientMalwareRequest_UrlInfo& from) {
+  ClientMalwareRequest_UrlInfo* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientMalwareRequest.UrlInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_ip(from._internal_ip());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_method(from._internal_method());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_referrer(from._internal_referrer());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.resource_type_ = from._impl_.resource_type_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientMalwareRequest_UrlInfo::CopyFrom(const ClientMalwareRequest_UrlInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientMalwareRequest.UrlInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientMalwareRequest_UrlInfo::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  return true;
+}
+
+void ClientMalwareRequest_UrlInfo::InternalSwap(ClientMalwareRequest_UrlInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.ip_, lhs_arena,
+      &other->_impl_.ip_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.method_, lhs_arena,
+      &other->_impl_.method_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.referrer_, lhs_arena,
+      &other->_impl_.referrer_, rhs_arena
+  );
+  swap(_impl_.resource_type_, other->_impl_.resource_type_);
+}
+
+std::string ClientMalwareRequest_UrlInfo::GetTypeName() const {
+  return "safe_browsing.ClientMalwareRequest.UrlInfo";
+}
+
+
+// ===================================================================
+
+class ClientMalwareRequest::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientMalwareRequest>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_referrer_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::safe_browsing::ChromeUserPopulation& population(const ClientMalwareRequest* msg);
+  static void set_has_population(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
+  }
+};
+
+const ::safe_browsing::ChromeUserPopulation&
+ClientMalwareRequest::_Internal::population(const ClientMalwareRequest* msg) {
+  return *msg->_impl_.population_;
+}
+ClientMalwareRequest::ClientMalwareRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientMalwareRequest)
+}
+ClientMalwareRequest::ClientMalwareRequest(const ClientMalwareRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientMalwareRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.bad_ip_url_info_){from._impl_.bad_ip_url_info_}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.referrer_url_){}
+    , decltype(_impl_.population_){nullptr}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.referrer_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.referrer_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_referrer_url()) {
+    _this->_impl_.referrer_url_.Set(from._internal_referrer_url(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_population()) {
+    _this->_impl_.population_ = new ::safe_browsing::ChromeUserPopulation(*from._impl_.population_);
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientMalwareRequest)
+}
+
+inline void ClientMalwareRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.bad_ip_url_info_){arena}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.referrer_url_){}
+    , decltype(_impl_.population_){nullptr}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.referrer_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.referrer_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientMalwareRequest::~ClientMalwareRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientMalwareRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientMalwareRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.bad_ip_url_info_.~RepeatedPtrField();
+  _impl_.url_.Destroy();
+  _impl_.referrer_url_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.population_;
+}
+
+void ClientMalwareRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientMalwareRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientMalwareRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.bad_ip_url_info_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.referrer_url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.population_ != nullptr);
+      _impl_.population_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientMalwareRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string referrer_url = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_referrer_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientMalwareRequest.UrlInfo bad_ip_url_info = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_bad_ip_url_info(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ChromeUserPopulation population = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_population(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientMalwareRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientMalwareRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // optional string referrer_url = 4;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_referrer_url(), target);
+  }
+
+  // repeated .safe_browsing.ClientMalwareRequest.UrlInfo bad_ip_url_info = 7;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_bad_ip_url_info_size()); i < n; i++) {
+    const auto& repfield = this->_internal_bad_ip_url_info(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(7, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ChromeUserPopulation population = 9;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(9, _Internal::population(this),
+        _Internal::population(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientMalwareRequest)
+  return target;
+}
+
+size_t ClientMalwareRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientMalwareRequest)
+  size_t total_size = 0;
+
+  // required string url = 1;
+  if (_internal_has_url()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_url());
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientMalwareRequest.UrlInfo bad_ip_url_info = 7;
+  total_size += 1UL * this->_internal_bad_ip_url_info_size();
+  for (const auto& msg : this->_impl_.bad_ip_url_info_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000006u) {
+    // optional string referrer_url = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_referrer_url());
+    }
+
+    // optional .safe_browsing.ChromeUserPopulation population = 9;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.population_);
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientMalwareRequest::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientMalwareRequest*>(
+      &from));
+}
+
+void ClientMalwareRequest::MergeFrom(const ClientMalwareRequest& from) {
+  ClientMalwareRequest* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientMalwareRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.bad_ip_url_info_.MergeFrom(from._impl_.bad_ip_url_info_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_referrer_url(from._internal_referrer_url());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(
+          from._internal_population());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientMalwareRequest::CopyFrom(const ClientMalwareRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientMalwareRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientMalwareRequest::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.bad_ip_url_info_))
+    return false;
+  return true;
+}
+
+void ClientMalwareRequest::InternalSwap(ClientMalwareRequest* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.bad_ip_url_info_.InternalSwap(&other->_impl_.bad_ip_url_info_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.referrer_url_, lhs_arena,
+      &other->_impl_.referrer_url_, rhs_arena
+  );
+  swap(_impl_.population_, other->_impl_.population_);
+}
+
+std::string ClientMalwareRequest::GetTypeName() const {
+  return "safe_browsing.ClientMalwareRequest";
+}
+
+
+// ===================================================================
+
+class LoginReputationClientRequest_Frame_Form::_Internal {
+ public:
+  using HasBits = decltype(std::declval<LoginReputationClientRequest_Frame_Form>()._impl_._has_bits_);
+  static void set_has_action_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_has_password_field(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+LoginReputationClientRequest_Frame_Form::LoginReputationClientRequest_Frame_Form(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.LoginReputationClientRequest.Frame.Form)
+}
+LoginReputationClientRequest_Frame_Form::LoginReputationClientRequest_Frame_Form(const LoginReputationClientRequest_Frame_Form& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  LoginReputationClientRequest_Frame_Form* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.action_url_){}
+    , decltype(_impl_.has_password_field_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.action_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.action_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_action_url()) {
+    _this->_impl_.action_url_.Set(from._internal_action_url(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.has_password_field_ = from._impl_.has_password_field_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.LoginReputationClientRequest.Frame.Form)
+}
+
+inline void LoginReputationClientRequest_Frame_Form::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.action_url_){}
+    , decltype(_impl_.has_password_field_){false}
+  };
+  _impl_.action_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.action_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+LoginReputationClientRequest_Frame_Form::~LoginReputationClientRequest_Frame_Form() {
+  // @@protoc_insertion_point(destructor:safe_browsing.LoginReputationClientRequest.Frame.Form)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void LoginReputationClientRequest_Frame_Form::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.action_url_.Destroy();
+}
+
+void LoginReputationClientRequest_Frame_Form::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void LoginReputationClientRequest_Frame_Form::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.LoginReputationClientRequest.Frame.Form)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.action_url_.ClearNonDefaultToEmpty();
+  }
+  _impl_.has_password_field_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* LoginReputationClientRequest_Frame_Form::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string action_url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_action_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool has_password_field = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_has_password_field(&has_bits);
+          _impl_.has_password_field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* LoginReputationClientRequest_Frame_Form::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.LoginReputationClientRequest.Frame.Form)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string action_url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_action_url(), target);
+  }
+
+  // optional bool has_password_field = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_has_password_field(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.LoginReputationClientRequest.Frame.Form)
+  return target;
+}
+
+size_t LoginReputationClientRequest_Frame_Form::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.LoginReputationClientRequest.Frame.Form)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string action_url = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_action_url());
+    }
+
+    // optional bool has_password_field = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void LoginReputationClientRequest_Frame_Form::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const LoginReputationClientRequest_Frame_Form*>(
+      &from));
+}
+
+void LoginReputationClientRequest_Frame_Form::MergeFrom(const LoginReputationClientRequest_Frame_Form& from) {
+  LoginReputationClientRequest_Frame_Form* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.LoginReputationClientRequest.Frame.Form)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_action_url(from._internal_action_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.has_password_field_ = from._impl_.has_password_field_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void LoginReputationClientRequest_Frame_Form::CopyFrom(const LoginReputationClientRequest_Frame_Form& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.LoginReputationClientRequest.Frame.Form)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LoginReputationClientRequest_Frame_Form::IsInitialized() const {
+  return true;
+}
+
+void LoginReputationClientRequest_Frame_Form::InternalSwap(LoginReputationClientRequest_Frame_Form* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.action_url_, lhs_arena,
+      &other->_impl_.action_url_, rhs_arena
+  );
+  swap(_impl_.has_password_field_, other->_impl_.has_password_field_);
+}
+
+std::string LoginReputationClientRequest_Frame_Form::GetTypeName() const {
+  return "safe_browsing.LoginReputationClientRequest.Frame.Form";
+}
+
+
+// ===================================================================
+
+class LoginReputationClientRequest_Frame::_Internal {
+ public:
+  using HasBits = decltype(std::declval<LoginReputationClientRequest_Frame>()._impl_._has_bits_);
+  static void set_has_frame_index(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_parent_frame_index(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_has_password_field(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+LoginReputationClientRequest_Frame::LoginReputationClientRequest_Frame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.LoginReputationClientRequest.Frame)
+}
+LoginReputationClientRequest_Frame::LoginReputationClientRequest_Frame(const LoginReputationClientRequest_Frame& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  LoginReputationClientRequest_Frame* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.referrer_chain_){from._impl_.referrer_chain_}
+    , decltype(_impl_.forms_){from._impl_.forms_}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.frame_index_){}
+    , decltype(_impl_.parent_frame_index_){}
+    , decltype(_impl_.has_password_field_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(),
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.frame_index_, &from._impl_.frame_index_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.has_password_field_) -
+    reinterpret_cast<char*>(&_impl_.frame_index_)) + sizeof(_impl_.has_password_field_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.LoginReputationClientRequest.Frame)
+}
+
+inline void LoginReputationClientRequest_Frame::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.referrer_chain_){arena}
+    , decltype(_impl_.forms_){arena}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.frame_index_){0}
+    , decltype(_impl_.parent_frame_index_){0}
+    , decltype(_impl_.has_password_field_){false}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+LoginReputationClientRequest_Frame::~LoginReputationClientRequest_Frame() {
+  // @@protoc_insertion_point(destructor:safe_browsing.LoginReputationClientRequest.Frame)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void LoginReputationClientRequest_Frame::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.referrer_chain_.~RepeatedPtrField();
+  _impl_.forms_.~RepeatedPtrField();
+  _impl_.url_.Destroy();
+}
+
+void LoginReputationClientRequest_Frame::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void LoginReputationClientRequest_Frame::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.LoginReputationClientRequest.Frame)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.referrer_chain_.Clear();
+  _impl_.forms_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.url_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x0000000eu) {
+    ::memset(&_impl_.frame_index_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.has_password_field_) -
+        reinterpret_cast<char*>(&_impl_.frame_index_)) + sizeof(_impl_.has_password_field_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* LoginReputationClientRequest_Frame::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional int32 frame_index = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_frame_index(&has_bits);
+          _impl_.frame_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 parent_frame_index = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_parent_frame_index(&has_bits);
+          _impl_.parent_frame_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string url = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool has_password_field = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_has_password_field(&has_bits);
+          _impl_.has_password_field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ReferrerChainEntry referrer_chain = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_referrer_chain(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.LoginReputationClientRequest.Frame.Form forms = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_forms(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* LoginReputationClientRequest_Frame::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.LoginReputationClientRequest.Frame)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int32 frame_index = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_frame_index(), target);
+  }
+
+  // optional int32 parent_frame_index = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_parent_frame_index(), target);
+  }
+
+  // optional string url = 3;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_url(), target);
+  }
+
+  // optional bool has_password_field = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_has_password_field(), target);
+  }
+
+  // repeated .safe_browsing.ReferrerChainEntry referrer_chain = 5;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_referrer_chain_size()); i < n; i++) {
+    const auto& repfield = this->_internal_referrer_chain(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // repeated .safe_browsing.LoginReputationClientRequest.Frame.Form forms = 6;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_forms_size()); i < n; i++) {
+    const auto& repfield = this->_internal_forms(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(6, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.LoginReputationClientRequest.Frame)
+  return target;
+}
+
+size_t LoginReputationClientRequest_Frame::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.LoginReputationClientRequest.Frame)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ReferrerChainEntry referrer_chain = 5;
+  total_size += 1UL * this->_internal_referrer_chain_size();
+  for (const auto& msg : this->_impl_.referrer_chain_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .safe_browsing.LoginReputationClientRequest.Frame.Form forms = 6;
+  total_size += 1UL * this->_internal_forms_size();
+  for (const auto& msg : this->_impl_.forms_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string url = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional int32 frame_index = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_frame_index());
+    }
+
+    // optional int32 parent_frame_index = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_parent_frame_index());
+    }
+
+    // optional bool has_password_field = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void LoginReputationClientRequest_Frame::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const LoginReputationClientRequest_Frame*>(
+      &from));
+}
+
+void LoginReputationClientRequest_Frame::MergeFrom(const LoginReputationClientRequest_Frame& from) {
+  LoginReputationClientRequest_Frame* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.LoginReputationClientRequest.Frame)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.referrer_chain_.MergeFrom(from._impl_.referrer_chain_);
+  _this->_impl_.forms_.MergeFrom(from._impl_.forms_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.frame_index_ = from._impl_.frame_index_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.parent_frame_index_ = from._impl_.parent_frame_index_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.has_password_field_ = from._impl_.has_password_field_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void LoginReputationClientRequest_Frame::CopyFrom(const LoginReputationClientRequest_Frame& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.LoginReputationClientRequest.Frame)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LoginReputationClientRequest_Frame::IsInitialized() const {
+  return true;
+}
+
+void LoginReputationClientRequest_Frame::InternalSwap(LoginReputationClientRequest_Frame* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.referrer_chain_.InternalSwap(&other->_impl_.referrer_chain_);
+  _impl_.forms_.InternalSwap(&other->_impl_.forms_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(LoginReputationClientRequest_Frame, _impl_.has_password_field_)
+      + sizeof(LoginReputationClientRequest_Frame::_impl_.has_password_field_)
+      - PROTOBUF_FIELD_OFFSET(LoginReputationClientRequest_Frame, _impl_.frame_index_)>(
+          reinterpret_cast<char*>(&_impl_.frame_index_),
+          reinterpret_cast<char*>(&other->_impl_.frame_index_));
+}
+
+std::string LoginReputationClientRequest_Frame::GetTypeName() const {
+  return "safe_browsing.LoginReputationClientRequest.Frame";
+}
+
+
+// ===================================================================
+
+class LoginReputationClientRequest_PasswordReuseEvent::_Internal {
+ public:
+  using HasBits = decltype(std::declval<LoginReputationClientRequest_PasswordReuseEvent>()._impl_._has_bits_);
+  static void set_has_frame_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_is_chrome_signin_password(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_sync_account_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+LoginReputationClientRequest_PasswordReuseEvent::LoginReputationClientRequest_PasswordReuseEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent)
+}
+LoginReputationClientRequest_PasswordReuseEvent::LoginReputationClientRequest_PasswordReuseEvent(const LoginReputationClientRequest_PasswordReuseEvent& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  LoginReputationClientRequest_PasswordReuseEvent* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.domains_matching_password_){from._impl_.domains_matching_password_}
+    , decltype(_impl_.frame_id_){}
+    , decltype(_impl_.is_chrome_signin_password_){}
+    , decltype(_impl_.sync_account_type_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::memcpy(&_impl_.frame_id_, &from._impl_.frame_id_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.sync_account_type_) -
+    reinterpret_cast<char*>(&_impl_.frame_id_)) + sizeof(_impl_.sync_account_type_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent)
+}
+
+inline void LoginReputationClientRequest_PasswordReuseEvent::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.domains_matching_password_){arena}
+    , decltype(_impl_.frame_id_){0}
+    , decltype(_impl_.is_chrome_signin_password_){false}
+    , decltype(_impl_.sync_account_type_){0}
+  };
+}
+
+LoginReputationClientRequest_PasswordReuseEvent::~LoginReputationClientRequest_PasswordReuseEvent() {
+  // @@protoc_insertion_point(destructor:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void LoginReputationClientRequest_PasswordReuseEvent::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.domains_matching_password_.~RepeatedPtrField();
+}
+
+void LoginReputationClientRequest_PasswordReuseEvent::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void LoginReputationClientRequest_PasswordReuseEvent::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.domains_matching_password_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    ::memset(&_impl_.frame_id_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.sync_account_type_) -
+        reinterpret_cast<char*>(&_impl_.frame_id_)) + sizeof(_impl_.sync_account_type_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* LoginReputationClientRequest_PasswordReuseEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated string domains_matching_password = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_domains_matching_password();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 frame_id = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_frame_id(&has_bits);
+          _impl_.frame_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool is_chrome_signin_password = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_is_chrome_signin_password(&has_bits);
+          _impl_.is_chrome_signin_password_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.SyncAccountType sync_account_type = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_IsValid(val))) {
+            _internal_set_sync_account_type(static_cast<::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* LoginReputationClientRequest_PasswordReuseEvent::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string domains_matching_password = 1;
+  for (int i = 0, n = this->_internal_domains_matching_password_size(); i < n; i++) {
+    const auto& s = this->_internal_domains_matching_password(i);
+    target = stream->WriteString(1, s, target);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int32 frame_id = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_frame_id(), target);
+  }
+
+  // optional bool is_chrome_signin_password = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_is_chrome_signin_password(), target);
+  }
+
+  // optional .safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.SyncAccountType sync_account_type = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_sync_account_type(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent)
+  return target;
+}
+
+size_t LoginReputationClientRequest_PasswordReuseEvent::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string domains_matching_password = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.domains_matching_password_.size());
+  for (int i = 0, n = _impl_.domains_matching_password_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.domains_matching_password_.Get(i));
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional int32 frame_id = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_frame_id());
+    }
+
+    // optional bool is_chrome_signin_password = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 1;
+    }
+
+    // optional .safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.SyncAccountType sync_account_type = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_sync_account_type());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void LoginReputationClientRequest_PasswordReuseEvent::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const LoginReputationClientRequest_PasswordReuseEvent*>(
+      &from));
+}
+
+void LoginReputationClientRequest_PasswordReuseEvent::MergeFrom(const LoginReputationClientRequest_PasswordReuseEvent& from) {
+  LoginReputationClientRequest_PasswordReuseEvent* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.domains_matching_password_.MergeFrom(from._impl_.domains_matching_password_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.frame_id_ = from._impl_.frame_id_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.is_chrome_signin_password_ = from._impl_.is_chrome_signin_password_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.sync_account_type_ = from._impl_.sync_account_type_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void LoginReputationClientRequest_PasswordReuseEvent::CopyFrom(const LoginReputationClientRequest_PasswordReuseEvent& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LoginReputationClientRequest_PasswordReuseEvent::IsInitialized() const {
+  return true;
+}
+
+void LoginReputationClientRequest_PasswordReuseEvent::InternalSwap(LoginReputationClientRequest_PasswordReuseEvent* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.domains_matching_password_.InternalSwap(&other->_impl_.domains_matching_password_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(LoginReputationClientRequest_PasswordReuseEvent, _impl_.sync_account_type_)
+      + sizeof(LoginReputationClientRequest_PasswordReuseEvent::_impl_.sync_account_type_)
+      - PROTOBUF_FIELD_OFFSET(LoginReputationClientRequest_PasswordReuseEvent, _impl_.frame_id_)>(
+          reinterpret_cast<char*>(&_impl_.frame_id_),
+          reinterpret_cast<char*>(&other->_impl_.frame_id_));
+}
+
+std::string LoginReputationClientRequest_PasswordReuseEvent::GetTypeName() const {
+  return "safe_browsing.LoginReputationClientRequest.PasswordReuseEvent";
+}
+
+
+// ===================================================================
+
+class LoginReputationClientRequest::_Internal {
+ public:
+  using HasBits = decltype(std::declval<LoginReputationClientRequest>()._impl_._has_bits_);
+  static void set_has_page_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_trigger_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent& password_reuse_event(const LoginReputationClientRequest* msg);
+  static void set_has_password_reuse_event(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_stored_verdict_cnt(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::safe_browsing::ChromeUserPopulation& population(const LoginReputationClientRequest* msg);
+  static void set_has_population(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_clicked_through_interstitial(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+};
+
+const ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent&
+LoginReputationClientRequest::_Internal::password_reuse_event(const LoginReputationClientRequest* msg) {
+  return *msg->_impl_.password_reuse_event_;
+}
+const ::safe_browsing::ChromeUserPopulation&
+LoginReputationClientRequest::_Internal::population(const LoginReputationClientRequest* msg) {
+  return *msg->_impl_.population_;
+}
+LoginReputationClientRequest::LoginReputationClientRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.LoginReputationClientRequest)
+}
+LoginReputationClientRequest::LoginReputationClientRequest(const LoginReputationClientRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  LoginReputationClientRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.frames_){from._impl_.frames_}
+    , decltype(_impl_.page_url_){}
+    , decltype(_impl_.password_reuse_event_){nullptr}
+    , decltype(_impl_.population_){nullptr}
+    , decltype(_impl_.trigger_type_){}
+    , decltype(_impl_.stored_verdict_cnt_){}
+    , decltype(_impl_.clicked_through_interstitial_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.page_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.page_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_page_url()) {
+    _this->_impl_.page_url_.Set(from._internal_page_url(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_password_reuse_event()) {
+    _this->_impl_.password_reuse_event_ = new ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent(*from._impl_.password_reuse_event_);
+  }
+  if (from._internal_has_population()) {
+    _this->_impl_.population_ = new ::safe_browsing::ChromeUserPopulation(*from._impl_.population_);
+  }
+  ::memcpy(&_impl_.trigger_type_, &from._impl_.trigger_type_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.clicked_through_interstitial_) -
+    reinterpret_cast<char*>(&_impl_.trigger_type_)) + sizeof(_impl_.clicked_through_interstitial_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.LoginReputationClientRequest)
+}
+
+inline void LoginReputationClientRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.frames_){arena}
+    , decltype(_impl_.page_url_){}
+    , decltype(_impl_.password_reuse_event_){nullptr}
+    , decltype(_impl_.population_){nullptr}
+    , decltype(_impl_.trigger_type_){0}
+    , decltype(_impl_.stored_verdict_cnt_){0}
+    , decltype(_impl_.clicked_through_interstitial_){false}
+  };
+  _impl_.page_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.page_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+LoginReputationClientRequest::~LoginReputationClientRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.LoginReputationClientRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void LoginReputationClientRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.frames_.~RepeatedPtrField();
+  _impl_.page_url_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.password_reuse_event_;
+  if (this != internal_default_instance()) delete _impl_.population_;
+}
+
+void LoginReputationClientRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void LoginReputationClientRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.LoginReputationClientRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.frames_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.page_url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.password_reuse_event_ != nullptr);
+      _impl_.password_reuse_event_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.population_ != nullptr);
+      _impl_.population_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00000038u) {
+    ::memset(&_impl_.trigger_type_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.clicked_through_interstitial_) -
+        reinterpret_cast<char*>(&_impl_.trigger_type_)) + sizeof(_impl_.clicked_through_interstitial_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* LoginReputationClientRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string page_url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_page_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.LoginReputationClientRequest.TriggerType trigger_type = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::LoginReputationClientRequest_TriggerType_IsValid(val))) {
+            _internal_set_trigger_type(static_cast<::safe_browsing::LoginReputationClientRequest_TriggerType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.LoginReputationClientRequest.Frame frames = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_frames(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.LoginReputationClientRequest.PasswordReuseEvent password_reuse_event = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_password_reuse_event(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 stored_verdict_cnt = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_stored_verdict_cnt(&has_bits);
+          _impl_.stored_verdict_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ChromeUserPopulation population = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_population(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool clicked_through_interstitial = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_clicked_through_interstitial(&has_bits);
+          _impl_.clicked_through_interstitial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* LoginReputationClientRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.LoginReputationClientRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string page_url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_page_url(), target);
+  }
+
+  // optional .safe_browsing.LoginReputationClientRequest.TriggerType trigger_type = 2;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_trigger_type(), target);
+  }
+
+  // repeated .safe_browsing.LoginReputationClientRequest.Frame frames = 3;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_frames_size()); i < n; i++) {
+    const auto& repfield = this->_internal_frames(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.LoginReputationClientRequest.PasswordReuseEvent password_reuse_event = 4;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::password_reuse_event(this),
+        _Internal::password_reuse_event(this).GetCachedSize(), target, stream);
+  }
+
+  // optional int32 stored_verdict_cnt = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_stored_verdict_cnt(), target);
+  }
+
+  // optional .safe_browsing.ChromeUserPopulation population = 6;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::population(this),
+        _Internal::population(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bool clicked_through_interstitial = 7;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_clicked_through_interstitial(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.LoginReputationClientRequest)
+  return target;
+}
+
+size_t LoginReputationClientRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.LoginReputationClientRequest)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.LoginReputationClientRequest.Frame frames = 3;
+  total_size += 1UL * this->_internal_frames_size();
+  for (const auto& msg : this->_impl_.frames_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    // optional string page_url = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_page_url());
+    }
+
+    // optional .safe_browsing.LoginReputationClientRequest.PasswordReuseEvent password_reuse_event = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.password_reuse_event_);
+    }
+
+    // optional .safe_browsing.ChromeUserPopulation population = 6;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.population_);
+    }
+
+    // optional .safe_browsing.LoginReputationClientRequest.TriggerType trigger_type = 2;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_trigger_type());
+    }
+
+    // optional int32 stored_verdict_cnt = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_stored_verdict_cnt());
+    }
+
+    // optional bool clicked_through_interstitial = 7;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void LoginReputationClientRequest::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const LoginReputationClientRequest*>(
+      &from));
+}
+
+void LoginReputationClientRequest::MergeFrom(const LoginReputationClientRequest& from) {
+  LoginReputationClientRequest* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.LoginReputationClientRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.frames_.MergeFrom(from._impl_.frames_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_page_url(from._internal_page_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_password_reuse_event()->::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent::MergeFrom(
+          from._internal_password_reuse_event());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(
+          from._internal_population());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.trigger_type_ = from._impl_.trigger_type_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.stored_verdict_cnt_ = from._impl_.stored_verdict_cnt_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.clicked_through_interstitial_ = from._impl_.clicked_through_interstitial_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void LoginReputationClientRequest::CopyFrom(const LoginReputationClientRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.LoginReputationClientRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LoginReputationClientRequest::IsInitialized() const {
+  return true;
+}
+
+void LoginReputationClientRequest::InternalSwap(LoginReputationClientRequest* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.frames_.InternalSwap(&other->_impl_.frames_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.page_url_, lhs_arena,
+      &other->_impl_.page_url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(LoginReputationClientRequest, _impl_.clicked_through_interstitial_)
+      + sizeof(LoginReputationClientRequest::_impl_.clicked_through_interstitial_)
+      - PROTOBUF_FIELD_OFFSET(LoginReputationClientRequest, _impl_.password_reuse_event_)>(
+          reinterpret_cast<char*>(&_impl_.password_reuse_event_),
+          reinterpret_cast<char*>(&other->_impl_.password_reuse_event_));
+}
+
+std::string LoginReputationClientRequest::GetTypeName() const {
+  return "safe_browsing.LoginReputationClientRequest";
+}
+
+
+// ===================================================================
+
+class LoginReputationClientResponse::_Internal {
+ public:
+  using HasBits = decltype(std::declval<LoginReputationClientResponse>()._impl_._has_bits_);
+  static void set_has_verdict_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_cache_duration_sec(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_cache_expression(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_deprecated_cache_expression_exact_match(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_verdict_token(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+LoginReputationClientResponse::LoginReputationClientResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.LoginReputationClientResponse)
+}
+LoginReputationClientResponse::LoginReputationClientResponse(const LoginReputationClientResponse& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  LoginReputationClientResponse* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.cache_expression_){}
+    , decltype(_impl_.verdict_token_){}
+    , decltype(_impl_.cache_duration_sec_){}
+    , decltype(_impl_.verdict_type_){}
+    , decltype(_impl_.deprecated_cache_expression_exact_match_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.cache_expression_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.cache_expression_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_cache_expression()) {
+    _this->_impl_.cache_expression_.Set(from._internal_cache_expression(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.verdict_token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.verdict_token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_verdict_token()) {
+    _this->_impl_.verdict_token_.Set(from._internal_verdict_token(),
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.cache_duration_sec_, &from._impl_.cache_duration_sec_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.deprecated_cache_expression_exact_match_) -
+    reinterpret_cast<char*>(&_impl_.cache_duration_sec_)) + sizeof(_impl_.deprecated_cache_expression_exact_match_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.LoginReputationClientResponse)
+}
+
+inline void LoginReputationClientResponse::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.cache_expression_){}
+    , decltype(_impl_.verdict_token_){}
+    , decltype(_impl_.cache_duration_sec_){int64_t{0}}
+    , decltype(_impl_.verdict_type_){0}
+    , decltype(_impl_.deprecated_cache_expression_exact_match_){false}
+  };
+  _impl_.cache_expression_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.cache_expression_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.verdict_token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.verdict_token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+LoginReputationClientResponse::~LoginReputationClientResponse() {
+  // @@protoc_insertion_point(destructor:safe_browsing.LoginReputationClientResponse)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void LoginReputationClientResponse::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.cache_expression_.Destroy();
+  _impl_.verdict_token_.Destroy();
+}
+
+void LoginReputationClientResponse::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void LoginReputationClientResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.LoginReputationClientResponse)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.cache_expression_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.verdict_token_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x0000001cu) {
+    ::memset(&_impl_.cache_duration_sec_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.deprecated_cache_expression_exact_match_) -
+        reinterpret_cast<char*>(&_impl_.cache_duration_sec_)) + sizeof(_impl_.deprecated_cache_expression_exact_match_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* LoginReputationClientResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .safe_browsing.LoginReputationClientResponse.VerdictType verdict_type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::LoginReputationClientResponse_VerdictType_IsValid(val))) {
+            _internal_set_verdict_type(static_cast<::safe_browsing::LoginReputationClientResponse_VerdictType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 cache_duration_sec = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_cache_duration_sec(&has_bits);
+          _impl_.cache_duration_sec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string cache_expression = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_cache_expression();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool DEPRECATED_cache_expression_exact_match = 4 [deprecated = true];
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_deprecated_cache_expression_exact_match(&has_bits);
+          _impl_.deprecated_cache_expression_exact_match_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes verdict_token = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_verdict_token();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* LoginReputationClientResponse::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.LoginReputationClientResponse)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .safe_browsing.LoginReputationClientResponse.VerdictType verdict_type = 1;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_verdict_type(), target);
+  }
+
+  // optional int64 cache_duration_sec = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_cache_duration_sec(), target);
+  }
+
+  // optional string cache_expression = 3;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_cache_expression(), target);
+  }
+
+  // optional bool DEPRECATED_cache_expression_exact_match = 4 [deprecated = true];
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_deprecated_cache_expression_exact_match(), target);
+  }
+
+  // optional bytes verdict_token = 5;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        5, this->_internal_verdict_token(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.LoginReputationClientResponse)
+  return target;
+}
+
+size_t LoginReputationClientResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.LoginReputationClientResponse)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional string cache_expression = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_cache_expression());
+    }
+
+    // optional bytes verdict_token = 5;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_verdict_token());
+    }
+
+    // optional int64 cache_duration_sec = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_cache_duration_sec());
+    }
+
+    // optional .safe_browsing.LoginReputationClientResponse.VerdictType verdict_type = 1;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_verdict_type());
+    }
+
+    // optional bool DEPRECATED_cache_expression_exact_match = 4 [deprecated = true];
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void LoginReputationClientResponse::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const LoginReputationClientResponse*>(
+      &from));
+}
+
+void LoginReputationClientResponse::MergeFrom(const LoginReputationClientResponse& from) {
+  LoginReputationClientResponse* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.LoginReputationClientResponse)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_cache_expression(from._internal_cache_expression());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_verdict_token(from._internal_verdict_token());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.cache_duration_sec_ = from._impl_.cache_duration_sec_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.verdict_type_ = from._impl_.verdict_type_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.deprecated_cache_expression_exact_match_ = from._impl_.deprecated_cache_expression_exact_match_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void LoginReputationClientResponse::CopyFrom(const LoginReputationClientResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.LoginReputationClientResponse)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LoginReputationClientResponse::IsInitialized() const {
+  return true;
+}
+
+void LoginReputationClientResponse::InternalSwap(LoginReputationClientResponse* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.cache_expression_, lhs_arena,
+      &other->_impl_.cache_expression_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.verdict_token_, lhs_arena,
+      &other->_impl_.verdict_token_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(LoginReputationClientResponse, _impl_.deprecated_cache_expression_exact_match_)
+      + sizeof(LoginReputationClientResponse::_impl_.deprecated_cache_expression_exact_match_)
+      - PROTOBUF_FIELD_OFFSET(LoginReputationClientResponse, _impl_.cache_duration_sec_)>(
+          reinterpret_cast<char*>(&_impl_.cache_duration_sec_),
+          reinterpret_cast<char*>(&other->_impl_.cache_duration_sec_));
+}
+
+std::string LoginReputationClientResponse::GetTypeName() const {
+  return "safe_browsing.LoginReputationClientResponse";
+}
+
+
+// ===================================================================
+
+class ClientMalwareResponse::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientMalwareResponse>()._impl_._has_bits_);
+  static void set_has_blacklist(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_bad_ip(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_bad_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000004) ^ 0x00000004) != 0;
+  }
+};
+
+ClientMalwareResponse::ClientMalwareResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientMalwareResponse)
+}
+ClientMalwareResponse::ClientMalwareResponse(const ClientMalwareResponse& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientMalwareResponse* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.bad_ip_){}
+    , decltype(_impl_.bad_url_){}
+    , decltype(_impl_.blacklist_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.bad_ip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.bad_ip_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_bad_ip()) {
+    _this->_impl_.bad_ip_.Set(from._internal_bad_ip(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.bad_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.bad_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_bad_url()) {
+    _this->_impl_.bad_url_.Set(from._internal_bad_url(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.blacklist_ = from._impl_.blacklist_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientMalwareResponse)
+}
+
+inline void ClientMalwareResponse::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.bad_ip_){}
+    , decltype(_impl_.bad_url_){}
+    , decltype(_impl_.blacklist_){false}
+  };
+  _impl_.bad_ip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.bad_ip_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.bad_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.bad_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientMalwareResponse::~ClientMalwareResponse() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientMalwareResponse)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientMalwareResponse::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.bad_ip_.Destroy();
+  _impl_.bad_url_.Destroy();
+}
+
+void ClientMalwareResponse::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientMalwareResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientMalwareResponse)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.bad_ip_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.bad_url_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.blacklist_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientMalwareResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required bool blacklist = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_blacklist(&has_bits);
+          _impl_.blacklist_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string bad_ip = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_bad_ip();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string bad_url = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_bad_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientMalwareResponse::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientMalwareResponse)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required bool blacklist = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(1, this->_internal_blacklist(), target);
+  }
+
+  // optional string bad_ip = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_bad_ip(), target);
+  }
+
+  // optional string bad_url = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_bad_url(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientMalwareResponse)
+  return target;
+}
+
+size_t ClientMalwareResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientMalwareResponse)
+  size_t total_size = 0;
+
+  // required bool blacklist = 1;
+  if (_internal_has_blacklist()) {
+    total_size += 1 + 1;
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string bad_ip = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_bad_ip());
+    }
+
+    // optional string bad_url = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_bad_url());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientMalwareResponse::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientMalwareResponse*>(
+      &from));
+}
+
+void ClientMalwareResponse::MergeFrom(const ClientMalwareResponse& from) {
+  ClientMalwareResponse* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientMalwareResponse)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_bad_ip(from._internal_bad_ip());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_bad_url(from._internal_bad_url());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.blacklist_ = from._impl_.blacklist_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientMalwareResponse::CopyFrom(const ClientMalwareResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientMalwareResponse)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientMalwareResponse::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  return true;
+}
+
+void ClientMalwareResponse::InternalSwap(ClientMalwareResponse* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.bad_ip_, lhs_arena,
+      &other->_impl_.bad_ip_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.bad_url_, lhs_arena,
+      &other->_impl_.bad_url_, rhs_arena
+  );
+  swap(_impl_.blacklist_, other->_impl_.blacklist_);
+}
+
+std::string ClientMalwareResponse::GetTypeName() const {
+  return "safe_browsing.ClientMalwareResponse";
+}
+
+
+// ===================================================================
+
+class ClientDownloadRequest_Digests::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadRequest_Digests>()._impl_._has_bits_);
+  static void set_has_sha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_sha1(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_md5(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+ClientDownloadRequest_Digests::ClientDownloadRequest_Digests(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadRequest.Digests)
+}
+ClientDownloadRequest_Digests::ClientDownloadRequest_Digests(const ClientDownloadRequest_Digests& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadRequest_Digests* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.sha256_){}
+    , decltype(_impl_.sha1_){}
+    , decltype(_impl_.md5_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.sha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.sha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_sha256()) {
+    _this->_impl_.sha256_.Set(from._internal_sha256(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.sha1_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.sha1_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_sha1()) {
+    _this->_impl_.sha1_.Set(from._internal_sha1(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.md5_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.md5_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_md5()) {
+    _this->_impl_.md5_.Set(from._internal_md5(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.Digests)
+}
+
+inline void ClientDownloadRequest_Digests::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.sha256_){}
+    , decltype(_impl_.sha1_){}
+    , decltype(_impl_.md5_){}
+  };
+  _impl_.sha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.sha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.sha1_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.sha1_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.md5_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.md5_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadRequest_Digests::~ClientDownloadRequest_Digests() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.Digests)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadRequest_Digests::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.sha256_.Destroy();
+  _impl_.sha1_.Destroy();
+  _impl_.md5_.Destroy();
+}
+
+void ClientDownloadRequest_Digests::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadRequest_Digests::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.Digests)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.sha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.sha1_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.md5_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadRequest_Digests::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes sha256 = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_sha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes sha1 = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_sha1();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes md5 = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_md5();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadRequest_Digests::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.Digests)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes sha256 = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_sha256(), target);
+  }
+
+  // optional bytes sha1 = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_sha1(), target);
+  }
+
+  // optional bytes md5 = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_md5(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadRequest.Digests)
+  return target;
+}
+
+size_t ClientDownloadRequest_Digests::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadRequest.Digests)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional bytes sha256 = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_sha256());
+    }
+
+    // optional bytes sha1 = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_sha1());
+    }
+
+    // optional bytes md5 = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_md5());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadRequest_Digests::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadRequest_Digests*>(
+      &from));
+}
+
+void ClientDownloadRequest_Digests::MergeFrom(const ClientDownloadRequest_Digests& from) {
+  ClientDownloadRequest_Digests* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.Digests)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_sha256(from._internal_sha256());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_sha1(from._internal_sha1());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_md5(from._internal_md5());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadRequest_Digests::CopyFrom(const ClientDownloadRequest_Digests& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadRequest.Digests)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_Digests::IsInitialized() const {
+  return true;
+}
+
+void ClientDownloadRequest_Digests::InternalSwap(ClientDownloadRequest_Digests* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.sha256_, lhs_arena,
+      &other->_impl_.sha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.sha1_, lhs_arena,
+      &other->_impl_.sha1_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.md5_, lhs_arena,
+      &other->_impl_.md5_, rhs_arena
+  );
+}
+
+std::string ClientDownloadRequest_Digests::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.Digests";
+}
+
+
+// ===================================================================
+
+class ClientDownloadRequest_Resource::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadRequest_Resource>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_remote_ip(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_referrer(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000009) ^ 0x00000009) != 0;
+  }
+};
+
+ClientDownloadRequest_Resource::ClientDownloadRequest_Resource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadRequest.Resource)
+}
+ClientDownloadRequest_Resource::ClientDownloadRequest_Resource(const ClientDownloadRequest_Resource& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadRequest_Resource* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.remote_ip_){}
+    , decltype(_impl_.referrer_){}
+    , decltype(_impl_.type_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.remote_ip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.remote_ip_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_remote_ip()) {
+    _this->_impl_.remote_ip_.Set(from._internal_remote_ip(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.referrer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.referrer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_referrer()) {
+    _this->_impl_.referrer_.Set(from._internal_referrer(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.type_ = from._impl_.type_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.Resource)
+}
+
+inline void ClientDownloadRequest_Resource::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.remote_ip_){}
+    , decltype(_impl_.referrer_){}
+    , decltype(_impl_.type_){0}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.remote_ip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.remote_ip_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.referrer_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.referrer_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadRequest_Resource::~ClientDownloadRequest_Resource() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.Resource)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadRequest_Resource::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.url_.Destroy();
+  _impl_.remote_ip_.Destroy();
+  _impl_.referrer_.Destroy();
+}
+
+void ClientDownloadRequest_Resource::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadRequest_Resource::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.Resource)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.remote_ip_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.referrer_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.type_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadRequest_Resource::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // required .safe_browsing.ClientDownloadRequest.ResourceType type = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientDownloadRequest_ResourceType_IsValid(val))) {
+            _internal_set_type(static_cast<::safe_browsing::ClientDownloadRequest_ResourceType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes remote_ip = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_remote_ip();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string referrer = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_referrer();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadRequest_Resource::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.Resource)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // required .safe_browsing.ClientDownloadRequest.ResourceType type = 2;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_type(), target);
+  }
+
+  // optional bytes remote_ip = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_remote_ip(), target);
+  }
+
+  // optional string referrer = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_referrer(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadRequest.Resource)
+  return target;
+}
+
+size_t ClientDownloadRequest_Resource::RequiredFieldsByteSizeFallback() const {
+// @@protoc_insertion_point(required_fields_byte_size_fallback_start:safe_browsing.ClientDownloadRequest.Resource)
+  size_t total_size = 0;
+
+  if (_internal_has_url()) {
+    // required string url = 1;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_url());
+  }
+
+  if (_internal_has_type()) {
+    // required .safe_browsing.ClientDownloadRequest.ResourceType type = 2;
+    total_size += 1 +
+      ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
+  }
+
+  return total_size;
+}
+size_t ClientDownloadRequest_Resource::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadRequest.Resource)
+  size_t total_size = 0;
+
+  if (((_impl_._has_bits_[0] & 0x00000009) ^ 0x00000009) == 0) {  // All required fields are present.
+    // required string url = 1;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_url());
+
+    // required .safe_browsing.ClientDownloadRequest.ResourceType type = 2;
+    total_size += 1 +
+      ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
+
+  } else {
+    total_size += RequiredFieldsByteSizeFallback();
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000006u) {
+    // optional bytes remote_ip = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_remote_ip());
+    }
+
+    // optional string referrer = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_referrer());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadRequest_Resource::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadRequest_Resource*>(
+      &from));
+}
+
+void ClientDownloadRequest_Resource::MergeFrom(const ClientDownloadRequest_Resource& from) {
+  ClientDownloadRequest_Resource* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.Resource)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_remote_ip(from._internal_remote_ip());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_referrer(from._internal_referrer());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.type_ = from._impl_.type_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadRequest_Resource::CopyFrom(const ClientDownloadRequest_Resource& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadRequest.Resource)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_Resource::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  return true;
+}
+
+void ClientDownloadRequest_Resource::InternalSwap(ClientDownloadRequest_Resource* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.remote_ip_, lhs_arena,
+      &other->_impl_.remote_ip_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.referrer_, lhs_arena,
+      &other->_impl_.referrer_, rhs_arena
+  );
+  swap(_impl_.type_, other->_impl_.type_);
+}
+
+std::string ClientDownloadRequest_Resource::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.Resource";
+}
+
+
+// ===================================================================
+
+class ClientDownloadRequest_CertificateChain_Element::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadRequest_CertificateChain_Element>()._impl_._has_bits_);
+  static void set_has_certificate(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+ClientDownloadRequest_CertificateChain_Element::ClientDownloadRequest_CertificateChain_Element(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+}
+ClientDownloadRequest_CertificateChain_Element::ClientDownloadRequest_CertificateChain_Element(const ClientDownloadRequest_CertificateChain_Element& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadRequest_CertificateChain_Element* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.certificate_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.certificate_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.certificate_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_certificate()) {
+    _this->_impl_.certificate_.Set(from._internal_certificate(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+}
+
+inline void ClientDownloadRequest_CertificateChain_Element::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.certificate_){}
+  };
+  _impl_.certificate_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.certificate_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadRequest_CertificateChain_Element::~ClientDownloadRequest_CertificateChain_Element() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadRequest_CertificateChain_Element::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.certificate_.Destroy();
+}
+
+void ClientDownloadRequest_CertificateChain_Element::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadRequest_CertificateChain_Element::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.certificate_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadRequest_CertificateChain_Element::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes certificate = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_certificate();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadRequest_CertificateChain_Element::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes certificate = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_certificate(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+  return target;
+}
+
+size_t ClientDownloadRequest_CertificateChain_Element::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bytes certificate = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_certificate());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadRequest_CertificateChain_Element::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadRequest_CertificateChain_Element*>(
+      &from));
+}
+
+void ClientDownloadRequest_CertificateChain_Element::MergeFrom(const ClientDownloadRequest_CertificateChain_Element& from) {
+  ClientDownloadRequest_CertificateChain_Element* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_certificate()) {
+    _this->_internal_set_certificate(from._internal_certificate());
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadRequest_CertificateChain_Element::CopyFrom(const ClientDownloadRequest_CertificateChain_Element& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_CertificateChain_Element::IsInitialized() const {
+  return true;
+}
+
+void ClientDownloadRequest_CertificateChain_Element::InternalSwap(ClientDownloadRequest_CertificateChain_Element* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.certificate_, lhs_arena,
+      &other->_impl_.certificate_, rhs_arena
+  );
+}
+
+std::string ClientDownloadRequest_CertificateChain_Element::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.CertificateChain.Element";
+}
+
+
+// ===================================================================
+
+class ClientDownloadRequest_CertificateChain::_Internal {
+ public:
+};
+
+ClientDownloadRequest_CertificateChain::ClientDownloadRequest_CertificateChain(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadRequest.CertificateChain)
+}
+ClientDownloadRequest_CertificateChain::ClientDownloadRequest_CertificateChain(const ClientDownloadRequest_CertificateChain& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadRequest_CertificateChain* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_.element_){from._impl_.element_}
+    , /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.CertificateChain)
+}
+
+inline void ClientDownloadRequest_CertificateChain::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_.element_){arena}
+    , /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+ClientDownloadRequest_CertificateChain::~ClientDownloadRequest_CertificateChain() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.CertificateChain)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadRequest_CertificateChain::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.element_.~RepeatedPtrField();
+}
+
+void ClientDownloadRequest_CertificateChain::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadRequest_CertificateChain::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.CertificateChain)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.element_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadRequest_CertificateChain::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .safe_browsing.ClientDownloadRequest.CertificateChain.Element element = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_element(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadRequest_CertificateChain::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.CertificateChain)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientDownloadRequest.CertificateChain.Element element = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_element_size()); i < n; i++) {
+    const auto& repfield = this->_internal_element(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadRequest.CertificateChain)
+  return target;
+}
+
+size_t ClientDownloadRequest_CertificateChain::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadRequest.CertificateChain)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientDownloadRequest.CertificateChain.Element element = 1;
+  total_size += 1UL * this->_internal_element_size();
+  for (const auto& msg : this->_impl_.element_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadRequest_CertificateChain::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadRequest_CertificateChain*>(
+      &from));
+}
+
+void ClientDownloadRequest_CertificateChain::MergeFrom(const ClientDownloadRequest_CertificateChain& from) {
+  ClientDownloadRequest_CertificateChain* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.CertificateChain)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.element_.MergeFrom(from._impl_.element_);
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadRequest_CertificateChain::CopyFrom(const ClientDownloadRequest_CertificateChain& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadRequest.CertificateChain)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_CertificateChain::IsInitialized() const {
+  return true;
+}
+
+void ClientDownloadRequest_CertificateChain::InternalSwap(ClientDownloadRequest_CertificateChain* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  _impl_.element_.InternalSwap(&other->_impl_.element_);
+}
+
+std::string ClientDownloadRequest_CertificateChain::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.CertificateChain";
+}
+
+
+// ===================================================================
+
+class ClientDownloadRequest_ExtendedAttr::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadRequest_ExtendedAttr>()._impl_._has_bits_);
+  static void set_has_key(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_value(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
+  }
+};
+
+ClientDownloadRequest_ExtendedAttr::ClientDownloadRequest_ExtendedAttr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+}
+ClientDownloadRequest_ExtendedAttr::ClientDownloadRequest_ExtendedAttr(const ClientDownloadRequest_ExtendedAttr& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadRequest_ExtendedAttr* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){}
+    , decltype(_impl_.value_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.key_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.key_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_key()) {
+    _this->_impl_.key_.Set(from._internal_key(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.value_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.value_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_value()) {
+    _this->_impl_.value_.Set(from._internal_value(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+}
+
+inline void ClientDownloadRequest_ExtendedAttr::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.key_){}
+    , decltype(_impl_.value_){}
+  };
+  _impl_.key_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.key_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.value_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.value_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadRequest_ExtendedAttr::~ClientDownloadRequest_ExtendedAttr() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadRequest_ExtendedAttr::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.key_.Destroy();
+  _impl_.value_.Destroy();
+}
+
+void ClientDownloadRequest_ExtendedAttr::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadRequest_ExtendedAttr::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.key_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.value_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadRequest_ExtendedAttr::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required string key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_key();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_value();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadRequest_ExtendedAttr::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required string key = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_key(), target);
+  }
+
+  // optional bytes value = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_value(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+  return target;
+}
+
+size_t ClientDownloadRequest_ExtendedAttr::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+  size_t total_size = 0;
+
+  // required string key = 1;
+  if (_internal_has_key()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_key());
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bytes value = 2;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000002u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_value());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadRequest_ExtendedAttr::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadRequest_ExtendedAttr*>(
+      &from));
+}
+
+void ClientDownloadRequest_ExtendedAttr::MergeFrom(const ClientDownloadRequest_ExtendedAttr& from) {
+  ClientDownloadRequest_ExtendedAttr* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_key(from._internal_key());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_value(from._internal_value());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadRequest_ExtendedAttr::CopyFrom(const ClientDownloadRequest_ExtendedAttr& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_ExtendedAttr::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  return true;
+}
+
+void ClientDownloadRequest_ExtendedAttr::InternalSwap(ClientDownloadRequest_ExtendedAttr* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.key_, lhs_arena,
+      &other->_impl_.key_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.value_, lhs_arena,
+      &other->_impl_.value_, rhs_arena
+  );
+}
+
+std::string ClientDownloadRequest_ExtendedAttr::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.ExtendedAttr";
+}
+
+
+// ===================================================================
+
+class ClientDownloadRequest_SignatureInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadRequest_SignatureInfo>()._impl_._has_bits_);
+  static void set_has_trusted(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+ClientDownloadRequest_SignatureInfo::ClientDownloadRequest_SignatureInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadRequest.SignatureInfo)
+}
+ClientDownloadRequest_SignatureInfo::ClientDownloadRequest_SignatureInfo(const ClientDownloadRequest_SignatureInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadRequest_SignatureInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.certificate_chain_){from._impl_.certificate_chain_}
+    , decltype(_impl_.signed_data_){from._impl_.signed_data_}
+    , decltype(_impl_.xattr_){from._impl_.xattr_}
+    , decltype(_impl_.trusted_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _this->_impl_.trusted_ = from._impl_.trusted_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.SignatureInfo)
+}
+
+inline void ClientDownloadRequest_SignatureInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.certificate_chain_){arena}
+    , decltype(_impl_.signed_data_){arena}
+    , decltype(_impl_.xattr_){arena}
+    , decltype(_impl_.trusted_){false}
+  };
+}
+
+ClientDownloadRequest_SignatureInfo::~ClientDownloadRequest_SignatureInfo() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.SignatureInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadRequest_SignatureInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.certificate_chain_.~RepeatedPtrField();
+  _impl_.signed_data_.~RepeatedPtrField();
+  _impl_.xattr_.~RepeatedPtrField();
+}
+
+void ClientDownloadRequest_SignatureInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadRequest_SignatureInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.SignatureInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.certificate_chain_.Clear();
+  _impl_.signed_data_.Clear();
+  _impl_.xattr_.Clear();
+  _impl_.trusted_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadRequest_SignatureInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_certificate_chain(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool trusted = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_trusted(&has_bits);
+          _impl_.trusted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated bytes signed_data = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_signed_data();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientDownloadRequest.ExtendedAttr xattr = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_xattr(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadRequest_SignatureInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.SignatureInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_certificate_chain_size()); i < n; i++) {
+    const auto& repfield = this->_internal_certificate_chain(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bool trusted = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_trusted(), target);
+  }
+
+  // repeated bytes signed_data = 3;
+  for (int i = 0, n = this->_internal_signed_data_size(); i < n; i++) {
+    const auto& s = this->_internal_signed_data(i);
+    target = stream->WriteBytes(3, s, target);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.ExtendedAttr xattr = 4;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_xattr_size()); i < n; i++) {
+    const auto& repfield = this->_internal_xattr(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadRequest.SignatureInfo)
+  return target;
+}
+
+size_t ClientDownloadRequest_SignatureInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadRequest.SignatureInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1;
+  total_size += 1UL * this->_internal_certificate_chain_size();
+  for (const auto& msg : this->_impl_.certificate_chain_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated bytes signed_data = 3;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.signed_data_.size());
+  for (int i = 0, n = _impl_.signed_data_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+      _impl_.signed_data_.Get(i));
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.ExtendedAttr xattr = 4;
+  total_size += 1UL * this->_internal_xattr_size();
+  for (const auto& msg : this->_impl_.xattr_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // optional bool trusted = 2;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 + 1;
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadRequest_SignatureInfo::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadRequest_SignatureInfo*>(
+      &from));
+}
+
+void ClientDownloadRequest_SignatureInfo::MergeFrom(const ClientDownloadRequest_SignatureInfo& from) {
+  ClientDownloadRequest_SignatureInfo* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.SignatureInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.certificate_chain_.MergeFrom(from._impl_.certificate_chain_);
+  _this->_impl_.signed_data_.MergeFrom(from._impl_.signed_data_);
+  _this->_impl_.xattr_.MergeFrom(from._impl_.xattr_);
+  if (from._internal_has_trusted()) {
+    _this->_internal_set_trusted(from._internal_trusted());
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadRequest_SignatureInfo::CopyFrom(const ClientDownloadRequest_SignatureInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadRequest.SignatureInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_SignatureInfo::IsInitialized() const {
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.xattr_))
+    return false;
+  return true;
+}
+
+void ClientDownloadRequest_SignatureInfo::InternalSwap(ClientDownloadRequest_SignatureInfo* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.certificate_chain_.InternalSwap(&other->_impl_.certificate_chain_);
+  _impl_.signed_data_.InternalSwap(&other->_impl_.signed_data_);
+  _impl_.xattr_.InternalSwap(&other->_impl_.xattr_);
+  swap(_impl_.trusted_, other->_impl_.trusted_);
+}
+
+std::string ClientDownloadRequest_SignatureInfo::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.SignatureInfo";
+}
+
+
+// ===================================================================
+
+class ClientDownloadRequest_PEImageHeaders_DebugData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadRequest_PEImageHeaders_DebugData>()._impl_._has_bits_);
+  static void set_has_directory_entry(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_raw_data(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ClientDownloadRequest_PEImageHeaders_DebugData::ClientDownloadRequest_PEImageHeaders_DebugData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+}
+ClientDownloadRequest_PEImageHeaders_DebugData::ClientDownloadRequest_PEImageHeaders_DebugData(const ClientDownloadRequest_PEImageHeaders_DebugData& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadRequest_PEImageHeaders_DebugData* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.directory_entry_){}
+    , decltype(_impl_.raw_data_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.directory_entry_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directory_entry_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_directory_entry()) {
+    _this->_impl_.directory_entry_.Set(from._internal_directory_entry(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.raw_data_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.raw_data_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_raw_data()) {
+    _this->_impl_.raw_data_.Set(from._internal_raw_data(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+}
+
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.directory_entry_){}
+    , decltype(_impl_.raw_data_){}
+  };
+  _impl_.directory_entry_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.directory_entry_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.raw_data_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.raw_data_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadRequest_PEImageHeaders_DebugData::~ClientDownloadRequest_PEImageHeaders_DebugData() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.directory_entry_.Destroy();
+  _impl_.raw_data_.Destroy();
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.directory_entry_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.raw_data_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadRequest_PEImageHeaders_DebugData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes directory_entry = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_directory_entry();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes raw_data = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_raw_data();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadRequest_PEImageHeaders_DebugData::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes directory_entry = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_directory_entry(), target);
+  }
+
+  // optional bytes raw_data = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_raw_data(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+  return target;
+}
+
+size_t ClientDownloadRequest_PEImageHeaders_DebugData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes directory_entry = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_directory_entry());
+    }
+
+    // optional bytes raw_data = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_raw_data());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadRequest_PEImageHeaders_DebugData*>(
+      &from));
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::MergeFrom(const ClientDownloadRequest_PEImageHeaders_DebugData& from) {
+  ClientDownloadRequest_PEImageHeaders_DebugData* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_directory_entry(from._internal_directory_entry());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_raw_data(from._internal_raw_data());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::CopyFrom(const ClientDownloadRequest_PEImageHeaders_DebugData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_PEImageHeaders_DebugData::IsInitialized() const {
+  return true;
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::InternalSwap(ClientDownloadRequest_PEImageHeaders_DebugData* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.directory_entry_, lhs_arena,
+      &other->_impl_.directory_entry_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.raw_data_, lhs_arena,
+      &other->_impl_.raw_data_, rhs_arena
+  );
+}
+
+std::string ClientDownloadRequest_PEImageHeaders_DebugData::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData";
+}
+
+
+// ===================================================================
+
+class ClientDownloadRequest_PEImageHeaders::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadRequest_PEImageHeaders>()._impl_._has_bits_);
+  static void set_has_dos_header(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_file_header(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_optional_headers32(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_optional_headers64(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_export_section_data(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+};
+
+ClientDownloadRequest_PEImageHeaders::ClientDownloadRequest_PEImageHeaders(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+}
+ClientDownloadRequest_PEImageHeaders::ClientDownloadRequest_PEImageHeaders(const ClientDownloadRequest_PEImageHeaders& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadRequest_PEImageHeaders* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.section_header_){from._impl_.section_header_}
+    , decltype(_impl_.debug_data_){from._impl_.debug_data_}
+    , decltype(_impl_.dos_header_){}
+    , decltype(_impl_.file_header_){}
+    , decltype(_impl_.optional_headers32_){}
+    , decltype(_impl_.optional_headers64_){}
+    , decltype(_impl_.export_section_data_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.dos_header_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.dos_header_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_dos_header()) {
+    _this->_impl_.dos_header_.Set(from._internal_dos_header(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.file_header_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.file_header_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_file_header()) {
+    _this->_impl_.file_header_.Set(from._internal_file_header(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.optional_headers32_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.optional_headers32_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_optional_headers32()) {
+    _this->_impl_.optional_headers32_.Set(from._internal_optional_headers32(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.optional_headers64_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.optional_headers64_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_optional_headers64()) {
+    _this->_impl_.optional_headers64_.Set(from._internal_optional_headers64(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.export_section_data_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.export_section_data_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_export_section_data()) {
+    _this->_impl_.export_section_data_.Set(from._internal_export_section_data(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+}
+
+inline void ClientDownloadRequest_PEImageHeaders::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.section_header_){arena}
+    , decltype(_impl_.debug_data_){arena}
+    , decltype(_impl_.dos_header_){}
+    , decltype(_impl_.file_header_){}
+    , decltype(_impl_.optional_headers32_){}
+    , decltype(_impl_.optional_headers64_){}
+    , decltype(_impl_.export_section_data_){}
+  };
+  _impl_.dos_header_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.dos_header_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.file_header_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.file_header_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.optional_headers32_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.optional_headers32_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.optional_headers64_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.optional_headers64_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.export_section_data_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.export_section_data_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadRequest_PEImageHeaders::~ClientDownloadRequest_PEImageHeaders() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadRequest_PEImageHeaders::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.section_header_.~RepeatedPtrField();
+  _impl_.debug_data_.~RepeatedPtrField();
+  _impl_.dos_header_.Destroy();
+  _impl_.file_header_.Destroy();
+  _impl_.optional_headers32_.Destroy();
+  _impl_.optional_headers64_.Destroy();
+  _impl_.export_section_data_.Destroy();
+}
+
+void ClientDownloadRequest_PEImageHeaders::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadRequest_PEImageHeaders::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.section_header_.Clear();
+  _impl_.debug_data_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.dos_header_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.file_header_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.optional_headers32_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.optional_headers64_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.export_section_data_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadRequest_PEImageHeaders::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes dos_header = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_dos_header();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes file_header = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_file_header();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes optional_headers32 = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_optional_headers32();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes optional_headers64 = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_optional_headers64();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated bytes section_header = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_section_header();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes export_section_data = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_export_section_data();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData debug_data = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_debug_data(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadRequest_PEImageHeaders::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes dos_header = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_dos_header(), target);
+  }
+
+  // optional bytes file_header = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_file_header(), target);
+  }
+
+  // optional bytes optional_headers32 = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_optional_headers32(), target);
+  }
+
+  // optional bytes optional_headers64 = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_optional_headers64(), target);
+  }
+
+  // repeated bytes section_header = 5;
+  for (int i = 0, n = this->_internal_section_header_size(); i < n; i++) {
+    const auto& s = this->_internal_section_header(i);
+    target = stream->WriteBytes(5, s, target);
+  }
+
+  // optional bytes export_section_data = 6;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        6, this->_internal_export_section_data(), target);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData debug_data = 7;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_debug_data_size()); i < n; i++) {
+    const auto& repfield = this->_internal_debug_data(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(7, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+  return target;
+}
+
+size_t ClientDownloadRequest_PEImageHeaders::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated bytes section_header = 5;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.section_header_.size());
+  for (int i = 0, n = _impl_.section_header_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+      _impl_.section_header_.Get(i));
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData debug_data = 7;
+  total_size += 1UL * this->_internal_debug_data_size();
+  for (const auto& msg : this->_impl_.debug_data_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional bytes dos_header = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_dos_header());
+    }
+
+    // optional bytes file_header = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_file_header());
+    }
+
+    // optional bytes optional_headers32 = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_optional_headers32());
+    }
+
+    // optional bytes optional_headers64 = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_optional_headers64());
+    }
+
+    // optional bytes export_section_data = 6;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_export_section_data());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadRequest_PEImageHeaders::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadRequest_PEImageHeaders*>(
+      &from));
+}
+
+void ClientDownloadRequest_PEImageHeaders::MergeFrom(const ClientDownloadRequest_PEImageHeaders& from) {
+  ClientDownloadRequest_PEImageHeaders* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.section_header_.MergeFrom(from._impl_.section_header_);
+  _this->_impl_.debug_data_.MergeFrom(from._impl_.debug_data_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_dos_header(from._internal_dos_header());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_file_header(from._internal_file_header());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_optional_headers32(from._internal_optional_headers32());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_optional_headers64(from._internal_optional_headers64());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_export_section_data(from._internal_export_section_data());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadRequest_PEImageHeaders::CopyFrom(const ClientDownloadRequest_PEImageHeaders& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_PEImageHeaders::IsInitialized() const {
+  return true;
+}
+
+void ClientDownloadRequest_PEImageHeaders::InternalSwap(ClientDownloadRequest_PEImageHeaders* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.section_header_.InternalSwap(&other->_impl_.section_header_);
+  _impl_.debug_data_.InternalSwap(&other->_impl_.debug_data_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.dos_header_, lhs_arena,
+      &other->_impl_.dos_header_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.file_header_, lhs_arena,
+      &other->_impl_.file_header_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.optional_headers32_, lhs_arena,
+      &other->_impl_.optional_headers32_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.optional_headers64_, lhs_arena,
+      &other->_impl_.optional_headers64_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.export_section_data_, lhs_arena,
+      &other->_impl_.export_section_data_, rhs_arena
+  );
+}
+
+std::string ClientDownloadRequest_PEImageHeaders::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.PEImageHeaders";
+}
+
+
+// ===================================================================
+
+class ClientDownloadRequest_MachOHeaders_LoadCommand::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadRequest_MachOHeaders_LoadCommand>()._impl_._has_bits_);
+  static void set_has_command_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_command(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
+  }
+};
+
+ClientDownloadRequest_MachOHeaders_LoadCommand::ClientDownloadRequest_MachOHeaders_LoadCommand(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+}
+ClientDownloadRequest_MachOHeaders_LoadCommand::ClientDownloadRequest_MachOHeaders_LoadCommand(const ClientDownloadRequest_MachOHeaders_LoadCommand& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadRequest_MachOHeaders_LoadCommand* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.command_){}
+    , decltype(_impl_.command_id_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.command_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.command_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_command()) {
+    _this->_impl_.command_.Set(from._internal_command(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.command_id_ = from._impl_.command_id_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+}
+
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.command_){}
+    , decltype(_impl_.command_id_){0u}
+  };
+  _impl_.command_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.command_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadRequest_MachOHeaders_LoadCommand::~ClientDownloadRequest_MachOHeaders_LoadCommand() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.command_.Destroy();
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.command_.ClearNonDefaultToEmpty();
+  }
+  _impl_.command_id_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadRequest_MachOHeaders_LoadCommand::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required uint32 command_id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_command_id(&has_bits);
+          _impl_.command_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // required bytes command = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_command();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadRequest_MachOHeaders_LoadCommand::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required uint32 command_id = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_command_id(), target);
+  }
+
+  // required bytes command = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_command(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+  return target;
+}
+
+size_t ClientDownloadRequest_MachOHeaders_LoadCommand::RequiredFieldsByteSizeFallback() const {
+// @@protoc_insertion_point(required_fields_byte_size_fallback_start:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+  size_t total_size = 0;
+
+  if (_internal_has_command()) {
+    // required bytes command = 2;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_command());
+  }
+
+  if (_internal_has_command_id()) {
+    // required uint32 command_id = 1;
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_command_id());
+  }
+
+  return total_size;
+}
+size_t ClientDownloadRequest_MachOHeaders_LoadCommand::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+  size_t total_size = 0;
+
+  if (((_impl_._has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
+    // required bytes command = 2;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_command());
+
+    // required uint32 command_id = 1;
+    total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_command_id());
+
+  } else {
+    total_size += RequiredFieldsByteSizeFallback();
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadRequest_MachOHeaders_LoadCommand*>(
+      &from));
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::MergeFrom(const ClientDownloadRequest_MachOHeaders_LoadCommand& from) {
+  ClientDownloadRequest_MachOHeaders_LoadCommand* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_command(from._internal_command());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.command_id_ = from._impl_.command_id_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::CopyFrom(const ClientDownloadRequest_MachOHeaders_LoadCommand& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_MachOHeaders_LoadCommand::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  return true;
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::InternalSwap(ClientDownloadRequest_MachOHeaders_LoadCommand* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.command_, lhs_arena,
+      &other->_impl_.command_, rhs_arena
+  );
+  swap(_impl_.command_id_, other->_impl_.command_id_);
+}
+
+std::string ClientDownloadRequest_MachOHeaders_LoadCommand::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand";
+}
+
+
+// ===================================================================
+
+class ClientDownloadRequest_MachOHeaders::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadRequest_MachOHeaders>()._impl_._has_bits_);
+  static void set_has_mach_header(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
+  }
+};
+
+ClientDownloadRequest_MachOHeaders::ClientDownloadRequest_MachOHeaders(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadRequest.MachOHeaders)
+}
+ClientDownloadRequest_MachOHeaders::ClientDownloadRequest_MachOHeaders(const ClientDownloadRequest_MachOHeaders& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadRequest_MachOHeaders* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.load_commands_){from._impl_.load_commands_}
+    , decltype(_impl_.mach_header_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.mach_header_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mach_header_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mach_header()) {
+    _this->_impl_.mach_header_.Set(from._internal_mach_header(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.MachOHeaders)
+}
+
+inline void ClientDownloadRequest_MachOHeaders::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.load_commands_){arena}
+    , decltype(_impl_.mach_header_){}
+  };
+  _impl_.mach_header_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mach_header_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadRequest_MachOHeaders::~ClientDownloadRequest_MachOHeaders() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.MachOHeaders)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadRequest_MachOHeaders::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.load_commands_.~RepeatedPtrField();
+  _impl_.mach_header_.Destroy();
+}
+
+void ClientDownloadRequest_MachOHeaders::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadRequest_MachOHeaders::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.MachOHeaders)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.load_commands_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.mach_header_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadRequest_MachOHeaders::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required bytes mach_header = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_mach_header();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand load_commands = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_load_commands(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadRequest_MachOHeaders::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.MachOHeaders)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required bytes mach_header = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_mach_header(), target);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand load_commands = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_load_commands_size()); i < n; i++) {
+    const auto& repfield = this->_internal_load_commands(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadRequest.MachOHeaders)
+  return target;
+}
+
+size_t ClientDownloadRequest_MachOHeaders::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadRequest.MachOHeaders)
+  size_t total_size = 0;
+
+  // required bytes mach_header = 1;
+  if (_internal_has_mach_header()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_mach_header());
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand load_commands = 2;
+  total_size += 1UL * this->_internal_load_commands_size();
+  for (const auto& msg : this->_impl_.load_commands_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadRequest_MachOHeaders::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadRequest_MachOHeaders*>(
+      &from));
+}
+
+void ClientDownloadRequest_MachOHeaders::MergeFrom(const ClientDownloadRequest_MachOHeaders& from) {
+  ClientDownloadRequest_MachOHeaders* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.MachOHeaders)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.load_commands_.MergeFrom(from._impl_.load_commands_);
+  if (from._internal_has_mach_header()) {
+    _this->_internal_set_mach_header(from._internal_mach_header());
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadRequest_MachOHeaders::CopyFrom(const ClientDownloadRequest_MachOHeaders& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadRequest.MachOHeaders)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_MachOHeaders::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.load_commands_))
+    return false;
+  return true;
+}
+
+void ClientDownloadRequest_MachOHeaders::InternalSwap(ClientDownloadRequest_MachOHeaders* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.load_commands_.InternalSwap(&other->_impl_.load_commands_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mach_header_, lhs_arena,
+      &other->_impl_.mach_header_, rhs_arena
+  );
+}
+
+std::string ClientDownloadRequest_MachOHeaders::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.MachOHeaders";
+}
+
+
+// ===================================================================
+
+class ClientDownloadRequest_ImageHeaders::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadRequest_ImageHeaders>()._impl_._has_bits_);
+  static const ::safe_browsing::ClientDownloadRequest_PEImageHeaders& pe_headers(const ClientDownloadRequest_ImageHeaders* msg);
+  static void set_has_pe_headers(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::safe_browsing::ClientDownloadRequest_PEImageHeaders&
+ClientDownloadRequest_ImageHeaders::_Internal::pe_headers(const ClientDownloadRequest_ImageHeaders* msg) {
+  return *msg->_impl_.pe_headers_;
+}
+ClientDownloadRequest_ImageHeaders::ClientDownloadRequest_ImageHeaders(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadRequest.ImageHeaders)
+}
+ClientDownloadRequest_ImageHeaders::ClientDownloadRequest_ImageHeaders(const ClientDownloadRequest_ImageHeaders& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadRequest_ImageHeaders* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.mach_o_headers_){from._impl_.mach_o_headers_}
+    , decltype(_impl_.pe_headers_){nullptr}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  if (from._internal_has_pe_headers()) {
+    _this->_impl_.pe_headers_ = new ::safe_browsing::ClientDownloadRequest_PEImageHeaders(*from._impl_.pe_headers_);
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.ImageHeaders)
+}
+
+inline void ClientDownloadRequest_ImageHeaders::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.mach_o_headers_){arena}
+    , decltype(_impl_.pe_headers_){nullptr}
+  };
+}
+
+ClientDownloadRequest_ImageHeaders::~ClientDownloadRequest_ImageHeaders() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.ImageHeaders)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadRequest_ImageHeaders::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.mach_o_headers_.~RepeatedPtrField();
+  if (this != internal_default_instance()) delete _impl_.pe_headers_;
+}
+
+void ClientDownloadRequest_ImageHeaders::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadRequest_ImageHeaders::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.ImageHeaders)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.mach_o_headers_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.pe_headers_ != nullptr);
+    _impl_.pe_headers_->Clear();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadRequest_ImageHeaders::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_pe_headers(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders mach_o_headers = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_mach_o_headers(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadRequest_ImageHeaders::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.ImageHeaders)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::pe_headers(this),
+        _Internal::pe_headers(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders mach_o_headers = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_mach_o_headers_size()); i < n; i++) {
+    const auto& repfield = this->_internal_mach_o_headers(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadRequest.ImageHeaders)
+  return target;
+}
+
+size_t ClientDownloadRequest_ImageHeaders::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadRequest.ImageHeaders)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders mach_o_headers = 2;
+  total_size += 1UL * this->_internal_mach_o_headers_size();
+  for (const auto& msg : this->_impl_.mach_o_headers_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.pe_headers_);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadRequest_ImageHeaders::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadRequest_ImageHeaders*>(
+      &from));
+}
+
+void ClientDownloadRequest_ImageHeaders::MergeFrom(const ClientDownloadRequest_ImageHeaders& from) {
+  ClientDownloadRequest_ImageHeaders* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.ImageHeaders)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.mach_o_headers_.MergeFrom(from._impl_.mach_o_headers_);
+  if (from._internal_has_pe_headers()) {
+    _this->_internal_mutable_pe_headers()->::safe_browsing::ClientDownloadRequest_PEImageHeaders::MergeFrom(
+        from._internal_pe_headers());
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadRequest_ImageHeaders::CopyFrom(const ClientDownloadRequest_ImageHeaders& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadRequest.ImageHeaders)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_ImageHeaders::IsInitialized() const {
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.mach_o_headers_))
+    return false;
+  return true;
+}
+
+void ClientDownloadRequest_ImageHeaders::InternalSwap(ClientDownloadRequest_ImageHeaders* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.mach_o_headers_.InternalSwap(&other->_impl_.mach_o_headers_);
+  swap(_impl_.pe_headers_, other->_impl_.pe_headers_);
+}
+
+std::string ClientDownloadRequest_ImageHeaders::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.ImageHeaders";
+}
+
+
+// ===================================================================
+
+class ClientDownloadRequest_ArchivedBinary::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadRequest_ArchivedBinary>()._impl_._has_bits_);
+  static void set_has_file_basename(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_download_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static const ::safe_browsing::ClientDownloadRequest_Digests& digests(const ClientDownloadRequest_ArchivedBinary* msg);
+  static void set_has_digests(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_length(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature(const ClientDownloadRequest_ArchivedBinary* msg);
+  static void set_has_signature(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers(const ClientDownloadRequest_ArchivedBinary* msg);
+  static void set_has_image_headers(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::safe_browsing::ClientDownloadRequest_Digests&
+ClientDownloadRequest_ArchivedBinary::_Internal::digests(const ClientDownloadRequest_ArchivedBinary* msg) {
+  return *msg->_impl_.digests_;
+}
+const ::safe_browsing::ClientDownloadRequest_SignatureInfo&
+ClientDownloadRequest_ArchivedBinary::_Internal::signature(const ClientDownloadRequest_ArchivedBinary* msg) {
+  return *msg->_impl_.signature_;
+}
+const ::safe_browsing::ClientDownloadRequest_ImageHeaders&
+ClientDownloadRequest_ArchivedBinary::_Internal::image_headers(const ClientDownloadRequest_ArchivedBinary* msg) {
+  return *msg->_impl_.image_headers_;
+}
+ClientDownloadRequest_ArchivedBinary::ClientDownloadRequest_ArchivedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+}
+ClientDownloadRequest_ArchivedBinary::ClientDownloadRequest_ArchivedBinary(const ClientDownloadRequest_ArchivedBinary& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadRequest_ArchivedBinary* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.file_basename_){}
+    , decltype(_impl_.digests_){nullptr}
+    , decltype(_impl_.signature_){nullptr}
+    , decltype(_impl_.image_headers_){nullptr}
+    , decltype(_impl_.length_){}
+    , decltype(_impl_.download_type_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.file_basename_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.file_basename_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_file_basename()) {
+    _this->_impl_.file_basename_.Set(from._internal_file_basename(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_digests()) {
+    _this->_impl_.digests_ = new ::safe_browsing::ClientDownloadRequest_Digests(*from._impl_.digests_);
+  }
+  if (from._internal_has_signature()) {
+    _this->_impl_.signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo(*from._impl_.signature_);
+  }
+  if (from._internal_has_image_headers()) {
+    _this->_impl_.image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders(*from._impl_.image_headers_);
+  }
+  ::memcpy(&_impl_.length_, &from._impl_.length_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.download_type_) -
+    reinterpret_cast<char*>(&_impl_.length_)) + sizeof(_impl_.download_type_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+}
+
+inline void ClientDownloadRequest_ArchivedBinary::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.file_basename_){}
+    , decltype(_impl_.digests_){nullptr}
+    , decltype(_impl_.signature_){nullptr}
+    , decltype(_impl_.image_headers_){nullptr}
+    , decltype(_impl_.length_){int64_t{0}}
+    , decltype(_impl_.download_type_){0}
+  };
+  _impl_.file_basename_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.file_basename_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadRequest_ArchivedBinary::~ClientDownloadRequest_ArchivedBinary() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadRequest_ArchivedBinary::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.file_basename_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.digests_;
+  if (this != internal_default_instance()) delete _impl_.signature_;
+  if (this != internal_default_instance()) delete _impl_.image_headers_;
+}
+
+void ClientDownloadRequest_ArchivedBinary::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadRequest_ArchivedBinary::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.file_basename_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.digests_ != nullptr);
+      _impl_.digests_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.signature_ != nullptr);
+      _impl_.signature_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.image_headers_ != nullptr);
+      _impl_.image_headers_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00000030u) {
+    ::memset(&_impl_.length_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.download_type_) -
+        reinterpret_cast<char*>(&_impl_.length_)) + sizeof(_impl_.download_type_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadRequest_ArchivedBinary::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string file_basename = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_file_basename();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientDownloadRequest_DownloadType_IsValid(val))) {
+            _internal_set_download_type(static_cast<::safe_browsing::ClientDownloadRequest_DownloadType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest.Digests digests = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_digests(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 length = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_length(&has_bits);
+          _impl_.length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_signature(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_image_headers(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadRequest_ArchivedBinary::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string file_basename = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_file_basename(), target);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 2;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_download_type(), target);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.Digests digests = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::digests(this),
+        _Internal::digests(this).GetCachedSize(), target, stream);
+  }
+
+  // optional int64 length = 4;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_length(), target);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(5, _Internal::signature(this),
+        _Internal::signature(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(6, _Internal::image_headers(this),
+        _Internal::image_headers(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+  return target;
+}
+
+size_t ClientDownloadRequest_ArchivedBinary::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    // optional string file_basename = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_file_basename());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.Digests digests = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.digests_);
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.signature_);
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.image_headers_);
+    }
+
+    // optional int64 length = 4;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_length());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 2;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_download_type());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadRequest_ArchivedBinary::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadRequest_ArchivedBinary*>(
+      &from));
+}
+
+void ClientDownloadRequest_ArchivedBinary::MergeFrom(const ClientDownloadRequest_ArchivedBinary& from) {
+  ClientDownloadRequest_ArchivedBinary* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_file_basename(from._internal_file_basename());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_digests()->::safe_browsing::ClientDownloadRequest_Digests::MergeFrom(
+          from._internal_digests());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(
+          from._internal_signature());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(
+          from._internal_image_headers());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.length_ = from._impl_.length_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.download_type_ = from._impl_.download_type_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadRequest_ArchivedBinary::CopyFrom(const ClientDownloadRequest_ArchivedBinary& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_ArchivedBinary::IsInitialized() const {
+  if (_internal_has_signature()) {
+    if (!_impl_.signature_->IsInitialized()) return false;
+  }
+  if (_internal_has_image_headers()) {
+    if (!_impl_.image_headers_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientDownloadRequest_ArchivedBinary::InternalSwap(ClientDownloadRequest_ArchivedBinary* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.file_basename_, lhs_arena,
+      &other->_impl_.file_basename_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientDownloadRequest_ArchivedBinary, _impl_.download_type_)
+      + sizeof(ClientDownloadRequest_ArchivedBinary::_impl_.download_type_)
+      - PROTOBUF_FIELD_OFFSET(ClientDownloadRequest_ArchivedBinary, _impl_.digests_)>(
+          reinterpret_cast<char*>(&_impl_.digests_),
+          reinterpret_cast<char*>(&other->_impl_.digests_));
+}
+
+std::string ClientDownloadRequest_ArchivedBinary::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.ArchivedBinary";
+}
+
+
+// ===================================================================
+
+class ClientDownloadRequest::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadRequest>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::safe_browsing::ClientDownloadRequest_Digests& digests(const ClientDownloadRequest* msg);
+  static void set_has_digests(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_length(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature(const ClientDownloadRequest* msg);
+  static void set_has_signature(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_user_initiated(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_file_basename(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_download_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_locale(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers(const ClientDownloadRequest* msg);
+  static void set_has_image_headers(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static const ::safe_browsing::ChromeUserPopulation& population(const ClientDownloadRequest* msg);
+  static void set_has_population(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_archive_valid(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_skipped_url_whitelist(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static void set_has_skipped_certificate_whitelist(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static void set_has_deprecated_download_attribution_finch_enabled(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static void set_has_udif_code_signature(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000111) ^ 0x00000111) != 0;
+  }
+};
+
+const ::safe_browsing::ClientDownloadRequest_Digests&
+ClientDownloadRequest::_Internal::digests(const ClientDownloadRequest* msg) {
+  return *msg->_impl_.digests_;
+}
+const ::safe_browsing::ClientDownloadRequest_SignatureInfo&
+ClientDownloadRequest::_Internal::signature(const ClientDownloadRequest* msg) {
+  return *msg->_impl_.signature_;
+}
+const ::safe_browsing::ClientDownloadRequest_ImageHeaders&
+ClientDownloadRequest::_Internal::image_headers(const ClientDownloadRequest* msg) {
+  return *msg->_impl_.image_headers_;
+}
+const ::safe_browsing::ChromeUserPopulation&
+ClientDownloadRequest::_Internal::population(const ClientDownloadRequest* msg) {
+  return *msg->_impl_.population_;
+}
+ClientDownloadRequest::ClientDownloadRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadRequest)
+}
+ClientDownloadRequest::ClientDownloadRequest(const ClientDownloadRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.resources_){from._impl_.resources_}
+    , decltype(_impl_.archived_binary_){from._impl_.archived_binary_}
+    , decltype(_impl_.alternate_extensions_){from._impl_.alternate_extensions_}
+    , decltype(_impl_.referrer_chain_){from._impl_.referrer_chain_}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.file_basename_){}
+    , decltype(_impl_.locale_){}
+    , decltype(_impl_.udif_code_signature_){}
+    , decltype(_impl_.digests_){nullptr}
+    , decltype(_impl_.signature_){nullptr}
+    , decltype(_impl_.image_headers_){nullptr}
+    , decltype(_impl_.population_){nullptr}
+    , decltype(_impl_.length_){}
+    , decltype(_impl_.download_type_){}
+    , decltype(_impl_.user_initiated_){}
+    , decltype(_impl_.archive_valid_){}
+    , decltype(_impl_.skipped_url_whitelist_){}
+    , decltype(_impl_.skipped_certificate_whitelist_){}
+    , decltype(_impl_.deprecated_download_attribution_finch_enabled_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.file_basename_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.file_basename_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_file_basename()) {
+    _this->_impl_.file_basename_.Set(from._internal_file_basename(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.locale_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.locale_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_locale()) {
+    _this->_impl_.locale_.Set(from._internal_locale(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.udif_code_signature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.udif_code_signature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_udif_code_signature()) {
+    _this->_impl_.udif_code_signature_.Set(from._internal_udif_code_signature(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_digests()) {
+    _this->_impl_.digests_ = new ::safe_browsing::ClientDownloadRequest_Digests(*from._impl_.digests_);
+  }
+  if (from._internal_has_signature()) {
+    _this->_impl_.signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo(*from._impl_.signature_);
+  }
+  if (from._internal_has_image_headers()) {
+    _this->_impl_.image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders(*from._impl_.image_headers_);
+  }
+  if (from._internal_has_population()) {
+    _this->_impl_.population_ = new ::safe_browsing::ChromeUserPopulation(*from._impl_.population_);
+  }
+  ::memcpy(&_impl_.length_, &from._impl_.length_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.deprecated_download_attribution_finch_enabled_) -
+    reinterpret_cast<char*>(&_impl_.length_)) + sizeof(_impl_.deprecated_download_attribution_finch_enabled_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest)
+}
+
+inline void ClientDownloadRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.resources_){arena}
+    , decltype(_impl_.archived_binary_){arena}
+    , decltype(_impl_.alternate_extensions_){arena}
+    , decltype(_impl_.referrer_chain_){arena}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.file_basename_){}
+    , decltype(_impl_.locale_){}
+    , decltype(_impl_.udif_code_signature_){}
+    , decltype(_impl_.digests_){nullptr}
+    , decltype(_impl_.signature_){nullptr}
+    , decltype(_impl_.image_headers_){nullptr}
+    , decltype(_impl_.population_){nullptr}
+    , decltype(_impl_.length_){int64_t{0}}
+    , decltype(_impl_.download_type_){0}
+    , decltype(_impl_.user_initiated_){false}
+    , decltype(_impl_.archive_valid_){false}
+    , decltype(_impl_.skipped_url_whitelist_){false}
+    , decltype(_impl_.skipped_certificate_whitelist_){false}
+    , decltype(_impl_.deprecated_download_attribution_finch_enabled_){false}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.file_basename_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.file_basename_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.locale_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.locale_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.udif_code_signature_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.udif_code_signature_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadRequest::~ClientDownloadRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.resources_.~RepeatedPtrField();
+  _impl_.archived_binary_.~RepeatedPtrField();
+  _impl_.alternate_extensions_.~RepeatedPtrField();
+  _impl_.referrer_chain_.~RepeatedPtrField();
+  _impl_.url_.Destroy();
+  _impl_.file_basename_.Destroy();
+  _impl_.locale_.Destroy();
+  _impl_.udif_code_signature_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.digests_;
+  if (this != internal_default_instance()) delete _impl_.signature_;
+  if (this != internal_default_instance()) delete _impl_.image_headers_;
+  if (this != internal_default_instance()) delete _impl_.population_;
+}
+
+void ClientDownloadRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.resources_.Clear();
+  _impl_.archived_binary_.Clear();
+  _impl_.alternate_extensions_.Clear();
+  _impl_.referrer_chain_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.file_basename_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.locale_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.udif_code_signature_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.digests_ != nullptr);
+      _impl_.digests_->Clear();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      GOOGLE_DCHECK(_impl_.signature_ != nullptr);
+      _impl_.signature_->Clear();
+    }
+    if (cached_has_bits & 0x00000040u) {
+      GOOGLE_DCHECK(_impl_.image_headers_ != nullptr);
+      _impl_.image_headers_->Clear();
+    }
+    if (cached_has_bits & 0x00000080u) {
+      GOOGLE_DCHECK(_impl_.population_ != nullptr);
+      _impl_.population_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00007f00u) {
+    ::memset(&_impl_.length_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.deprecated_download_attribution_finch_enabled_) -
+        reinterpret_cast<char*>(&_impl_.length_)) + sizeof(_impl_.deprecated_download_attribution_finch_enabled_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // required .safe_browsing.ClientDownloadRequest.Digests digests = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_digests(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // required int64 length = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_length(&has_bits);
+          _impl_.length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_resources(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_signature(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool user_initiated = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_user_initiated(&has_bits);
+          _impl_.user_initiated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string file_basename = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_file_basename();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 10 [default = WIN_EXECUTABLE];
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientDownloadRequest_DownloadType_IsValid(val))) {
+            _internal_set_download_type(static_cast<::safe_browsing::ClientDownloadRequest_DownloadType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string locale = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          auto str = _internal_mutable_locale();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 146)) {
+          ptr = ctx->ParseMessage(_internal_mutable_image_headers(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientDownloadRequest.ArchivedBinary archived_binary = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 178)) {
+          ptr -= 2;
+          do {
+            ptr += 2;
+            ptr = ctx->ParseMessage(_internal_add_archived_binary(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<178>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ChromeUserPopulation population = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 194)) {
+          ptr = ctx->ParseMessage(_internal_mutable_population(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool archive_valid = 26;
+      case 26:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 208)) {
+          _Internal::set_has_archive_valid(&has_bits);
+          _impl_.archive_valid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool skipped_url_whitelist = 28;
+      case 28:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 224)) {
+          _Internal::set_has_skipped_url_whitelist(&has_bits);
+          _impl_.skipped_url_whitelist_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool skipped_certificate_whitelist = 31;
+      case 31:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
+          _Internal::set_has_skipped_certificate_whitelist(&has_bits);
+          _impl_.skipped_certificate_whitelist_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string alternate_extensions = 35;
+      case 35:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 2;
+          do {
+            ptr += 2;
+            auto str = _internal_add_alternate_extensions();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<282>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ReferrerChainEntry referrer_chain = 36;
+      case 36:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr -= 2;
+          do {
+            ptr += 2;
+            ptr = ctx->ParseMessage(_internal_add_referrer_chain(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<290>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool DEPRECATED_download_attribution_finch_enabled = 39 [deprecated = true];
+      case 39:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_deprecated_download_attribution_finch_enabled(&has_bits);
+          _impl_.deprecated_download_attribution_finch_enabled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes udif_code_signature = 40;
+      case 40:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          auto str = _internal_mutable_udif_code_signature();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // required .safe_browsing.ClientDownloadRequest.Digests digests = 2;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::digests(this),
+        _Internal::digests(this).GetCachedSize(), target, stream);
+  }
+
+  // required int64 length = 3;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_length(), target);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_resources_size()); i < n; i++) {
+    const auto& repfield = this->_internal_resources(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(5, _Internal::signature(this),
+        _Internal::signature(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bool user_initiated = 6;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_user_initiated(), target);
+  }
+
+  // optional string file_basename = 9;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        9, this->_internal_file_basename(), target);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 10 [default = WIN_EXECUTABLE];
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      10, this->_internal_download_type(), target);
+  }
+
+  // optional string locale = 11;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteStringMaybeAliased(
+        11, this->_internal_locale(), target);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 18;
+  if (cached_has_bits & 0x00000040u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(18, _Internal::image_headers(this),
+        _Internal::image_headers(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.ArchivedBinary archived_binary = 22;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_archived_binary_size()); i < n; i++) {
+    const auto& repfield = this->_internal_archived_binary(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(22, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ChromeUserPopulation population = 24;
+  if (cached_has_bits & 0x00000080u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(24, _Internal::population(this),
+        _Internal::population(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bool archive_valid = 26;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(26, this->_internal_archive_valid(), target);
+  }
+
+  // optional bool skipped_url_whitelist = 28;
+  if (cached_has_bits & 0x00001000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(28, this->_internal_skipped_url_whitelist(), target);
+  }
+
+  // optional bool skipped_certificate_whitelist = 31;
+  if (cached_has_bits & 0x00002000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(31, this->_internal_skipped_certificate_whitelist(), target);
+  }
+
+  // repeated string alternate_extensions = 35;
+  for (int i = 0, n = this->_internal_alternate_extensions_size(); i < n; i++) {
+    const auto& s = this->_internal_alternate_extensions(i);
+    target = stream->WriteString(35, s, target);
+  }
+
+  // repeated .safe_browsing.ReferrerChainEntry referrer_chain = 36;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_referrer_chain_size()); i < n; i++) {
+    const auto& repfield = this->_internal_referrer_chain(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(36, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional bool DEPRECATED_download_attribution_finch_enabled = 39 [deprecated = true];
+  if (cached_has_bits & 0x00004000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(39, this->_internal_deprecated_download_attribution_finch_enabled(), target);
+  }
+
+  // optional bytes udif_code_signature = 40;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteBytesMaybeAliased(
+        40, this->_internal_udif_code_signature(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadRequest)
+  return target;
+}
+
+size_t ClientDownloadRequest::RequiredFieldsByteSizeFallback() const {
+// @@protoc_insertion_point(required_fields_byte_size_fallback_start:safe_browsing.ClientDownloadRequest)
+  size_t total_size = 0;
+
+  if (_internal_has_url()) {
+    // required string url = 1;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_url());
+  }
+
+  if (_internal_has_digests()) {
+    // required .safe_browsing.ClientDownloadRequest.Digests digests = 2;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.digests_);
+  }
+
+  if (_internal_has_length()) {
+    // required int64 length = 3;
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_length());
+  }
+
+  return total_size;
+}
+size_t ClientDownloadRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadRequest)
+  size_t total_size = 0;
+
+  if (((_impl_._has_bits_[0] & 0x00000111) ^ 0x00000111) == 0) {  // All required fields are present.
+    // required string url = 1;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_url());
+
+    // required .safe_browsing.ClientDownloadRequest.Digests digests = 2;
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.digests_);
+
+    // required int64 length = 3;
+    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_length());
+
+  } else {
+    total_size += RequiredFieldsByteSizeFallback();
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4;
+  total_size += 1UL * this->_internal_resources_size();
+  for (const auto& msg : this->_impl_.resources_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.ArchivedBinary archived_binary = 22;
+  total_size += 2UL * this->_internal_archived_binary_size();
+  for (const auto& msg : this->_impl_.archived_binary_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated string alternate_extensions = 35;
+  total_size += 2 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.alternate_extensions_.size());
+  for (int i = 0, n = _impl_.alternate_extensions_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.alternate_extensions_.Get(i));
+  }
+
+  // repeated .safe_browsing.ReferrerChainEntry referrer_chain = 36;
+  total_size += 2UL * this->_internal_referrer_chain_size();
+  for (const auto& msg : this->_impl_.referrer_chain_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000eu) {
+    // optional string file_basename = 9;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_file_basename());
+    }
+
+    // optional string locale = 11;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_locale());
+    }
+
+    // optional bytes udif_code_signature = 40;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_udif_code_signature());
+    }
+
+  }
+  if (cached_has_bits & 0x000000e0u) {
+    // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.signature_);
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 18;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.image_headers_);
+    }
+
+    // optional .safe_browsing.ChromeUserPopulation population = 24;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.population_);
+    }
+
+  }
+  if (cached_has_bits & 0x00007e00u) {
+    // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 10 [default = WIN_EXECUTABLE];
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_download_type());
+    }
+
+    // optional bool user_initiated = 6;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool archive_valid = 26;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool skipped_url_whitelist = 28;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool skipped_certificate_whitelist = 31;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool DEPRECATED_download_attribution_finch_enabled = 39 [deprecated = true];
+    if (cached_has_bits & 0x00004000u) {
+      total_size += 2 + 1;
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadRequest::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadRequest*>(
+      &from));
+}
+
+void ClientDownloadRequest::MergeFrom(const ClientDownloadRequest& from) {
+  ClientDownloadRequest* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.resources_.MergeFrom(from._impl_.resources_);
+  _this->_impl_.archived_binary_.MergeFrom(from._impl_.archived_binary_);
+  _this->_impl_.alternate_extensions_.MergeFrom(from._impl_.alternate_extensions_);
+  _this->_impl_.referrer_chain_.MergeFrom(from._impl_.referrer_chain_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_file_basename(from._internal_file_basename());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_locale(from._internal_locale());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_udif_code_signature(from._internal_udif_code_signature());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_digests()->::safe_browsing::ClientDownloadRequest_Digests::MergeFrom(
+          from._internal_digests());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(
+          from._internal_signature());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_internal_mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(
+          from._internal_image_headers());
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_internal_mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(
+          from._internal_population());
+    }
+  }
+  if (cached_has_bits & 0x00007f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.length_ = from._impl_.length_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.download_type_ = from._impl_.download_type_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.user_initiated_ = from._impl_.user_initiated_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.archive_valid_ = from._impl_.archive_valid_;
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_impl_.skipped_url_whitelist_ = from._impl_.skipped_url_whitelist_;
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_impl_.skipped_certificate_whitelist_ = from._impl_.skipped_certificate_whitelist_;
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_impl_.deprecated_download_attribution_finch_enabled_ = from._impl_.deprecated_download_attribution_finch_enabled_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadRequest::CopyFrom(const ClientDownloadRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.resources_))
+    return false;
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.archived_binary_))
+    return false;
+  if (_internal_has_signature()) {
+    if (!_impl_.signature_->IsInitialized()) return false;
+  }
+  if (_internal_has_image_headers()) {
+    if (!_impl_.image_headers_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientDownloadRequest::InternalSwap(ClientDownloadRequest* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.resources_.InternalSwap(&other->_impl_.resources_);
+  _impl_.archived_binary_.InternalSwap(&other->_impl_.archived_binary_);
+  _impl_.alternate_extensions_.InternalSwap(&other->_impl_.alternate_extensions_);
+  _impl_.referrer_chain_.InternalSwap(&other->_impl_.referrer_chain_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.file_basename_, lhs_arena,
+      &other->_impl_.file_basename_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.locale_, lhs_arena,
+      &other->_impl_.locale_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.udif_code_signature_, lhs_arena,
+      &other->_impl_.udif_code_signature_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientDownloadRequest, _impl_.deprecated_download_attribution_finch_enabled_)
+      + sizeof(ClientDownloadRequest::_impl_.deprecated_download_attribution_finch_enabled_)
+      - PROTOBUF_FIELD_OFFSET(ClientDownloadRequest, _impl_.digests_)>(
+          reinterpret_cast<char*>(&_impl_.digests_),
+          reinterpret_cast<char*>(&other->_impl_.digests_));
+}
+
+std::string ClientDownloadRequest::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest";
+}
+
+
+// ===================================================================
+
+class ReferrerChainEntry_ServerRedirect::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ReferrerChainEntry_ServerRedirect>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+ReferrerChainEntry_ServerRedirect::ReferrerChainEntry_ServerRedirect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ReferrerChainEntry.ServerRedirect)
+}
+ReferrerChainEntry_ServerRedirect::ReferrerChainEntry_ServerRedirect(const ReferrerChainEntry_ServerRedirect& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ReferrerChainEntry_ServerRedirect* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ReferrerChainEntry.ServerRedirect)
+}
+
+inline void ReferrerChainEntry_ServerRedirect::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.url_){}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ReferrerChainEntry_ServerRedirect::~ReferrerChainEntry_ServerRedirect() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ReferrerChainEntry.ServerRedirect)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ReferrerChainEntry_ServerRedirect::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.url_.Destroy();
+}
+
+void ReferrerChainEntry_ServerRedirect::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ReferrerChainEntry_ServerRedirect::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ReferrerChainEntry.ServerRedirect)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.url_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ReferrerChainEntry_ServerRedirect::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ReferrerChainEntry_ServerRedirect::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ReferrerChainEntry.ServerRedirect)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ReferrerChainEntry.ServerRedirect)
+  return target;
+}
+
+size_t ReferrerChainEntry_ServerRedirect::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ReferrerChainEntry.ServerRedirect)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string url = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_url());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ReferrerChainEntry_ServerRedirect::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ReferrerChainEntry_ServerRedirect*>(
+      &from));
+}
+
+void ReferrerChainEntry_ServerRedirect::MergeFrom(const ReferrerChainEntry_ServerRedirect& from) {
+  ReferrerChainEntry_ServerRedirect* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ReferrerChainEntry.ServerRedirect)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_url()) {
+    _this->_internal_set_url(from._internal_url());
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ReferrerChainEntry_ServerRedirect::CopyFrom(const ReferrerChainEntry_ServerRedirect& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ReferrerChainEntry.ServerRedirect)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ReferrerChainEntry_ServerRedirect::IsInitialized() const {
+  return true;
+}
+
+void ReferrerChainEntry_ServerRedirect::InternalSwap(ReferrerChainEntry_ServerRedirect* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+}
+
+std::string ReferrerChainEntry_ServerRedirect::GetTypeName() const {
+  return "safe_browsing.ReferrerChainEntry.ServerRedirect";
+}
+
+
+// ===================================================================
+
+class ReferrerChainEntry::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ReferrerChainEntry>()._impl_._has_bits_);
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_main_frame_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_referrer_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_referrer_main_frame_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_is_retargeting(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_navigation_time_msec(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+};
+
+ReferrerChainEntry::ReferrerChainEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ReferrerChainEntry)
+}
+ReferrerChainEntry::ReferrerChainEntry(const ReferrerChainEntry& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ReferrerChainEntry* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.ip_addresses_){from._impl_.ip_addresses_}
+    , decltype(_impl_.server_redirect_chain_){from._impl_.server_redirect_chain_}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.referrer_url_){}
+    , decltype(_impl_.referrer_main_frame_url_){}
+    , decltype(_impl_.main_frame_url_){}
+    , decltype(_impl_.navigation_time_msec_){}
+    , decltype(_impl_.is_retargeting_){}
+    , decltype(_impl_.type_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.referrer_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.referrer_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_referrer_url()) {
+    _this->_impl_.referrer_url_.Set(from._internal_referrer_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.referrer_main_frame_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.referrer_main_frame_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_referrer_main_frame_url()) {
+    _this->_impl_.referrer_main_frame_url_.Set(from._internal_referrer_main_frame_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.main_frame_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.main_frame_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_main_frame_url()) {
+    _this->_impl_.main_frame_url_.Set(from._internal_main_frame_url(),
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.navigation_time_msec_, &from._impl_.navigation_time_msec_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.type_) -
+    reinterpret_cast<char*>(&_impl_.navigation_time_msec_)) + sizeof(_impl_.type_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ReferrerChainEntry)
+}
+
+inline void ReferrerChainEntry::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.ip_addresses_){arena}
+    , decltype(_impl_.server_redirect_chain_){arena}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.referrer_url_){}
+    , decltype(_impl_.referrer_main_frame_url_){}
+    , decltype(_impl_.main_frame_url_){}
+    , decltype(_impl_.navigation_time_msec_){0}
+    , decltype(_impl_.is_retargeting_){false}
+    , decltype(_impl_.type_){4}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.referrer_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.referrer_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.referrer_main_frame_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.referrer_main_frame_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.main_frame_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.main_frame_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ReferrerChainEntry::~ReferrerChainEntry() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ReferrerChainEntry)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ReferrerChainEntry::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.ip_addresses_.~RepeatedPtrField();
+  _impl_.server_redirect_chain_.~RepeatedPtrField();
+  _impl_.url_.Destroy();
+  _impl_.referrer_url_.Destroy();
+  _impl_.referrer_main_frame_url_.Destroy();
+  _impl_.main_frame_url_.Destroy();
+}
+
+void ReferrerChainEntry::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ReferrerChainEntry::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ReferrerChainEntry)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.ip_addresses_.Clear();
+  _impl_.server_redirect_chain_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.referrer_url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.referrer_main_frame_url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.main_frame_url_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x00000070u) {
+    ::memset(&_impl_.navigation_time_msec_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.is_retargeting_) -
+        reinterpret_cast<char*>(&_impl_.navigation_time_msec_)) + sizeof(_impl_.is_retargeting_));
+    _impl_.type_ = 4;
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ReferrerChainEntry::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ReferrerChainEntry.URLType type = 2 [default = CLIENT_REDIRECT];
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ReferrerChainEntry_URLType_IsValid(val))) {
+            _internal_set_type(static_cast<::safe_browsing::ReferrerChainEntry_URLType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string ip_addresses = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_ip_addresses();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string referrer_url = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_referrer_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string referrer_main_frame_url = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          auto str = _internal_mutable_referrer_main_frame_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool is_retargeting = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_is_retargeting(&has_bits);
+          _impl_.is_retargeting_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional double navigation_time_msec = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 57)) {
+          _Internal::set_has_navigation_time_msec(&has_bits);
+          _impl_.navigation_time_msec_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ReferrerChainEntry.ServerRedirect server_redirect_chain = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_server_redirect_chain(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string main_frame_url = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          auto str = _internal_mutable_main_frame_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ReferrerChainEntry::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ReferrerChainEntry)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // optional .safe_browsing.ReferrerChainEntry.URLType type = 2 [default = CLIENT_REDIRECT];
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_type(), target);
+  }
+
+  // repeated string ip_addresses = 3;
+  for (int i = 0, n = this->_internal_ip_addresses_size(); i < n; i++) {
+    const auto& s = this->_internal_ip_addresses(i);
+    target = stream->WriteString(3, s, target);
+  }
+
+  // optional string referrer_url = 4;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_referrer_url(), target);
+  }
+
+  // optional string referrer_main_frame_url = 5;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteStringMaybeAliased(
+        5, this->_internal_referrer_main_frame_url(), target);
+  }
+
+  // optional bool is_retargeting = 6;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_is_retargeting(), target);
+  }
+
+  // optional double navigation_time_msec = 7;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteDoubleToArray(7, this->_internal_navigation_time_msec(), target);
+  }
+
+  // repeated .safe_browsing.ReferrerChainEntry.ServerRedirect server_redirect_chain = 8;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_server_redirect_chain_size()); i < n; i++) {
+    const auto& repfield = this->_internal_server_redirect_chain(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(8, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional string main_frame_url = 9;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteStringMaybeAliased(
+        9, this->_internal_main_frame_url(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ReferrerChainEntry)
+  return target;
+}
+
+size_t ReferrerChainEntry::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ReferrerChainEntry)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string ip_addresses = 3;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.ip_addresses_.size());
+  for (int i = 0, n = _impl_.ip_addresses_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.ip_addresses_.Get(i));
+  }
+
+  // repeated .safe_browsing.ReferrerChainEntry.ServerRedirect server_redirect_chain = 8;
+  total_size += 1UL * this->_internal_server_redirect_chain_size();
+  for (const auto& msg : this->_impl_.server_redirect_chain_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    // optional string url = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional string referrer_url = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_referrer_url());
+    }
+
+    // optional string referrer_main_frame_url = 5;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_referrer_main_frame_url());
+    }
+
+    // optional string main_frame_url = 9;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_main_frame_url());
+    }
+
+    // optional double navigation_time_msec = 7;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 + 8;
+    }
+
+    // optional bool is_retargeting = 6;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 + 1;
+    }
+
+    // optional .safe_browsing.ReferrerChainEntry.URLType type = 2 [default = CLIENT_REDIRECT];
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ReferrerChainEntry::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ReferrerChainEntry*>(
+      &from));
+}
+
+void ReferrerChainEntry::MergeFrom(const ReferrerChainEntry& from) {
+  ReferrerChainEntry* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ReferrerChainEntry)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.ip_addresses_.MergeFrom(from._impl_.ip_addresses_);
+  _this->_impl_.server_redirect_chain_.MergeFrom(from._impl_.server_redirect_chain_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000007fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_referrer_url(from._internal_referrer_url());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_referrer_main_frame_url(from._internal_referrer_main_frame_url());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_main_frame_url(from._internal_main_frame_url());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.navigation_time_msec_ = from._impl_.navigation_time_msec_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.is_retargeting_ = from._impl_.is_retargeting_;
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.type_ = from._impl_.type_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ReferrerChainEntry::CopyFrom(const ReferrerChainEntry& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ReferrerChainEntry)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ReferrerChainEntry::IsInitialized() const {
+  return true;
+}
+
+void ReferrerChainEntry::InternalSwap(ReferrerChainEntry* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.ip_addresses_.InternalSwap(&other->_impl_.ip_addresses_);
+  _impl_.server_redirect_chain_.InternalSwap(&other->_impl_.server_redirect_chain_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.referrer_url_, lhs_arena,
+      &other->_impl_.referrer_url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.referrer_main_frame_url_, lhs_arena,
+      &other->_impl_.referrer_main_frame_url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.main_frame_url_, lhs_arena,
+      &other->_impl_.main_frame_url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ReferrerChainEntry, _impl_.is_retargeting_)
+      + sizeof(ReferrerChainEntry::_impl_.is_retargeting_)
+      - PROTOBUF_FIELD_OFFSET(ReferrerChainEntry, _impl_.navigation_time_msec_)>(
+          reinterpret_cast<char*>(&_impl_.navigation_time_msec_),
+          reinterpret_cast<char*>(&other->_impl_.navigation_time_msec_));
+  swap(_impl_.type_, other->_impl_.type_);
+}
+
+std::string ReferrerChainEntry::GetTypeName() const {
+  return "safe_browsing.ReferrerChainEntry";
+}
+
+
+// ===================================================================
+
+class ClientDownloadResponse_MoreInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadResponse_MoreInfo>()._impl_._has_bits_);
+  static void set_has_description(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ClientDownloadResponse_MoreInfo::ClientDownloadResponse_MoreInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadResponse.MoreInfo)
+}
+ClientDownloadResponse_MoreInfo::ClientDownloadResponse_MoreInfo(const ClientDownloadResponse_MoreInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadResponse_MoreInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.url_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_description()) {
+    _this->_impl_.description_.Set(from._internal_description(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadResponse.MoreInfo)
+}
+
+inline void ClientDownloadResponse_MoreInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.url_){}
+  };
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadResponse_MoreInfo::~ClientDownloadResponse_MoreInfo() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadResponse.MoreInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadResponse_MoreInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.description_.Destroy();
+  _impl_.url_.Destroy();
+}
+
+void ClientDownloadResponse_MoreInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadResponse_MoreInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadResponse.MoreInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.description_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadResponse_MoreInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string description = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_description();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string url = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadResponse_MoreInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadResponse.MoreInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string description = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_description(), target);
+  }
+
+  // optional string url = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_url(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadResponse.MoreInfo)
+  return target;
+}
+
+size_t ClientDownloadResponse_MoreInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadResponse.MoreInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string description = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_description());
+    }
+
+    // optional string url = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadResponse_MoreInfo::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadResponse_MoreInfo*>(
+      &from));
+}
+
+void ClientDownloadResponse_MoreInfo::MergeFrom(const ClientDownloadResponse_MoreInfo& from) {
+  ClientDownloadResponse_MoreInfo* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadResponse.MoreInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_description(from._internal_description());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadResponse_MoreInfo::CopyFrom(const ClientDownloadResponse_MoreInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadResponse.MoreInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadResponse_MoreInfo::IsInitialized() const {
+  return true;
+}
+
+void ClientDownloadResponse_MoreInfo::InternalSwap(ClientDownloadResponse_MoreInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.description_, lhs_arena,
+      &other->_impl_.description_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+}
+
+std::string ClientDownloadResponse_MoreInfo::GetTypeName() const {
+  return "safe_browsing.ClientDownloadResponse.MoreInfo";
+}
+
+
+// ===================================================================
+
+class ClientDownloadResponse::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadResponse>()._impl_._has_bits_);
+  static void set_has_verdict(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::safe_browsing::ClientDownloadResponse_MoreInfo& more_info(const ClientDownloadResponse* msg);
+  static void set_has_more_info(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_token(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_upload(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::safe_browsing::ClientDownloadResponse_MoreInfo&
+ClientDownloadResponse::_Internal::more_info(const ClientDownloadResponse* msg) {
+  return *msg->_impl_.more_info_;
+}
+ClientDownloadResponse::ClientDownloadResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadResponse)
+}
+ClientDownloadResponse::ClientDownloadResponse(const ClientDownloadResponse& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadResponse* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.token_){}
+    , decltype(_impl_.more_info_){nullptr}
+    , decltype(_impl_.verdict_){}
+    , decltype(_impl_.upload_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_token()) {
+    _this->_impl_.token_.Set(from._internal_token(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_more_info()) {
+    _this->_impl_.more_info_ = new ::safe_browsing::ClientDownloadResponse_MoreInfo(*from._impl_.more_info_);
+  }
+  ::memcpy(&_impl_.verdict_, &from._impl_.verdict_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.upload_) -
+    reinterpret_cast<char*>(&_impl_.verdict_)) + sizeof(_impl_.upload_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadResponse)
+}
+
+inline void ClientDownloadResponse::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.token_){}
+    , decltype(_impl_.more_info_){nullptr}
+    , decltype(_impl_.verdict_){0}
+    , decltype(_impl_.upload_){false}
+  };
+  _impl_.token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadResponse::~ClientDownloadResponse() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadResponse)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadResponse::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.token_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.more_info_;
+}
+
+void ClientDownloadResponse::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadResponse)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.token_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.more_info_ != nullptr);
+      _impl_.more_info_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000000cu) {
+    ::memset(&_impl_.verdict_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.upload_) -
+        reinterpret_cast<char*>(&_impl_.verdict_)) + sizeof(_impl_.upload_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .safe_browsing.ClientDownloadResponse.Verdict verdict = 1 [default = SAFE];
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientDownloadResponse_Verdict_IsValid(val))) {
+            _internal_set_verdict(static_cast<::safe_browsing::ClientDownloadResponse_Verdict>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadResponse.MoreInfo more_info = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_more_info(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes token = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_token();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool upload = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_upload(&has_bits);
+          _impl_.upload_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadResponse::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadResponse)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .safe_browsing.ClientDownloadResponse.Verdict verdict = 1 [default = SAFE];
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_verdict(), target);
+  }
+
+  // optional .safe_browsing.ClientDownloadResponse.MoreInfo more_info = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::more_info(this),
+        _Internal::more_info(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bytes token = 3;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_token(), target);
+  }
+
+  // optional bool upload = 5;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_upload(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadResponse)
+  return target;
+}
+
+size_t ClientDownloadResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadResponse)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional bytes token = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_token());
+    }
+
+    // optional .safe_browsing.ClientDownloadResponse.MoreInfo more_info = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.more_info_);
+    }
+
+    // optional .safe_browsing.ClientDownloadResponse.Verdict verdict = 1 [default = SAFE];
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_verdict());
+    }
+
+    // optional bool upload = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadResponse::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadResponse*>(
+      &from));
+}
+
+void ClientDownloadResponse::MergeFrom(const ClientDownloadResponse& from) {
+  ClientDownloadResponse* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadResponse)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_token(from._internal_token());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_more_info()->::safe_browsing::ClientDownloadResponse_MoreInfo::MergeFrom(
+          from._internal_more_info());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.verdict_ = from._impl_.verdict_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.upload_ = from._impl_.upload_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadResponse::CopyFrom(const ClientDownloadResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadResponse)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadResponse::IsInitialized() const {
+  return true;
+}
+
+void ClientDownloadResponse::InternalSwap(ClientDownloadResponse* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.token_, lhs_arena,
+      &other->_impl_.token_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientDownloadResponse, _impl_.upload_)
+      + sizeof(ClientDownloadResponse::_impl_.upload_)
+      - PROTOBUF_FIELD_OFFSET(ClientDownloadResponse, _impl_.more_info_)>(
+          reinterpret_cast<char*>(&_impl_.more_info_),
+          reinterpret_cast<char*>(&other->_impl_.more_info_));
+}
+
+std::string ClientDownloadResponse::GetTypeName() const {
+  return "safe_browsing.ClientDownloadResponse";
+}
+
+
+// ===================================================================
+
+class ClientDownloadReport_UserInformation::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadReport_UserInformation>()._impl_._has_bits_);
+  static void set_has_email(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+ClientDownloadReport_UserInformation::ClientDownloadReport_UserInformation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadReport.UserInformation)
+}
+ClientDownloadReport_UserInformation::ClientDownloadReport_UserInformation(const ClientDownloadReport_UserInformation& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadReport_UserInformation* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.email_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.email_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.email_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_email()) {
+    _this->_impl_.email_.Set(from._internal_email(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadReport.UserInformation)
+}
+
+inline void ClientDownloadReport_UserInformation::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.email_){}
+  };
+  _impl_.email_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.email_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadReport_UserInformation::~ClientDownloadReport_UserInformation() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadReport.UserInformation)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadReport_UserInformation::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.email_.Destroy();
+}
+
+void ClientDownloadReport_UserInformation::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadReport_UserInformation::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadReport.UserInformation)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.email_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadReport_UserInformation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string email = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_email();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadReport_UserInformation::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadReport.UserInformation)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string email = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_email(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadReport.UserInformation)
+  return target;
+}
+
+size_t ClientDownloadReport_UserInformation::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadReport.UserInformation)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional string email = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_email());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadReport_UserInformation::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadReport_UserInformation*>(
+      &from));
+}
+
+void ClientDownloadReport_UserInformation::MergeFrom(const ClientDownloadReport_UserInformation& from) {
+  ClientDownloadReport_UserInformation* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadReport.UserInformation)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_email()) {
+    _this->_internal_set_email(from._internal_email());
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadReport_UserInformation::CopyFrom(const ClientDownloadReport_UserInformation& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadReport.UserInformation)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadReport_UserInformation::IsInitialized() const {
+  return true;
+}
+
+void ClientDownloadReport_UserInformation::InternalSwap(ClientDownloadReport_UserInformation* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.email_, lhs_arena,
+      &other->_impl_.email_, rhs_arena
+  );
+}
+
+std::string ClientDownloadReport_UserInformation::GetTypeName() const {
+  return "safe_browsing.ClientDownloadReport.UserInformation";
+}
+
+
+// ===================================================================
+
+class ClientDownloadReport::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientDownloadReport>()._impl_._has_bits_);
+  static void set_has_reason(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::safe_browsing::ClientDownloadRequest& download_request(const ClientDownloadReport* msg);
+  static void set_has_download_request(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::safe_browsing::ClientDownloadReport_UserInformation& user_information(const ClientDownloadReport* msg);
+  static void set_has_user_information(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_comment(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::safe_browsing::ClientDownloadResponse& download_response(const ClientDownloadReport* msg);
+  static void set_has_download_response(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::safe_browsing::ClientDownloadRequest&
+ClientDownloadReport::_Internal::download_request(const ClientDownloadReport* msg) {
+  return *msg->_impl_.download_request_;
+}
+const ::safe_browsing::ClientDownloadReport_UserInformation&
+ClientDownloadReport::_Internal::user_information(const ClientDownloadReport* msg) {
+  return *msg->_impl_.user_information_;
+}
+const ::safe_browsing::ClientDownloadResponse&
+ClientDownloadReport::_Internal::download_response(const ClientDownloadReport* msg) {
+  return *msg->_impl_.download_response_;
+}
+ClientDownloadReport::ClientDownloadReport(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientDownloadReport)
+}
+ClientDownloadReport::ClientDownloadReport(const ClientDownloadReport& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientDownloadReport* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.comment_){}
+    , decltype(_impl_.download_request_){nullptr}
+    , decltype(_impl_.user_information_){nullptr}
+    , decltype(_impl_.download_response_){nullptr}
+    , decltype(_impl_.reason_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.comment_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.comment_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_comment()) {
+    _this->_impl_.comment_.Set(from._internal_comment(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_download_request()) {
+    _this->_impl_.download_request_ = new ::safe_browsing::ClientDownloadRequest(*from._impl_.download_request_);
+  }
+  if (from._internal_has_user_information()) {
+    _this->_impl_.user_information_ = new ::safe_browsing::ClientDownloadReport_UserInformation(*from._impl_.user_information_);
+  }
+  if (from._internal_has_download_response()) {
+    _this->_impl_.download_response_ = new ::safe_browsing::ClientDownloadResponse(*from._impl_.download_response_);
+  }
+  _this->_impl_.reason_ = from._impl_.reason_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadReport)
+}
+
+inline void ClientDownloadReport::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.comment_){}
+    , decltype(_impl_.download_request_){nullptr}
+    , decltype(_impl_.user_information_){nullptr}
+    , decltype(_impl_.download_response_){nullptr}
+    , decltype(_impl_.reason_){0}
+  };
+  _impl_.comment_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.comment_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientDownloadReport::~ClientDownloadReport() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadReport)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientDownloadReport::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.comment_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.download_request_;
+  if (this != internal_default_instance()) delete _impl_.user_information_;
+  if (this != internal_default_instance()) delete _impl_.download_response_;
+}
+
+void ClientDownloadReport::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientDownloadReport::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadReport)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.comment_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.download_request_ != nullptr);
+      _impl_.download_request_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.user_information_ != nullptr);
+      _impl_.user_information_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.download_response_ != nullptr);
+      _impl_.download_response_->Clear();
+    }
+  }
+  _impl_.reason_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientDownloadReport::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .safe_browsing.ClientDownloadReport.Reason reason = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientDownloadReport_Reason_IsValid(val))) {
+            _internal_set_reason(static_cast<::safe_browsing::ClientDownloadReport_Reason>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest download_request = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_download_request(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_user_information(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes comment = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_comment();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadResponse download_response = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_download_response(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientDownloadReport::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadReport)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .safe_browsing.ClientDownloadReport.Reason reason = 1;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_reason(), target);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest download_request = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::download_request(this),
+        _Internal::download_request(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::user_information(this),
+        _Internal::user_information(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bytes comment = 4;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_comment(), target);
+  }
+
+  // optional .safe_browsing.ClientDownloadResponse download_response = 5;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(5, _Internal::download_response(this),
+        _Internal::download_response(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientDownloadReport)
+  return target;
+}
+
+size_t ClientDownloadReport::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientDownloadReport)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional bytes comment = 4;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_comment());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest download_request = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.download_request_);
+    }
+
+    // optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.user_information_);
+    }
+
+    // optional .safe_browsing.ClientDownloadResponse download_response = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.download_response_);
+    }
+
+    // optional .safe_browsing.ClientDownloadReport.Reason reason = 1;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_reason());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientDownloadReport::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientDownloadReport*>(
+      &from));
+}
+
+void ClientDownloadReport::MergeFrom(const ClientDownloadReport& from) {
+  ClientDownloadReport* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadReport)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_comment(from._internal_comment());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_download_request()->::safe_browsing::ClientDownloadRequest::MergeFrom(
+          from._internal_download_request());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_user_information()->::safe_browsing::ClientDownloadReport_UserInformation::MergeFrom(
+          from._internal_user_information());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_download_response()->::safe_browsing::ClientDownloadResponse::MergeFrom(
+          from._internal_download_response());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.reason_ = from._impl_.reason_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientDownloadReport::CopyFrom(const ClientDownloadReport& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientDownloadReport)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadReport::IsInitialized() const {
+  if (_internal_has_download_request()) {
+    if (!_impl_.download_request_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientDownloadReport::InternalSwap(ClientDownloadReport* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.comment_, lhs_arena,
+      &other->_impl_.comment_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientDownloadReport, _impl_.reason_)
+      + sizeof(ClientDownloadReport::_impl_.reason_)
+      - PROTOBUF_FIELD_OFFSET(ClientDownloadReport, _impl_.download_request_)>(
+          reinterpret_cast<char*>(&_impl_.download_request_),
+          reinterpret_cast<char*>(&other->_impl_.download_request_));
+}
+
+std::string ClientDownloadReport::GetTypeName() const {
+  return "safe_browsing.ClientDownloadReport";
+}
+
+
+// ===================================================================
+
+class ClientUploadResponse::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientUploadResponse>()._impl_._has_bits_);
+  static void set_has_status(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_permalink(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+ClientUploadResponse::ClientUploadResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientUploadResponse)
+}
+ClientUploadResponse::ClientUploadResponse(const ClientUploadResponse& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientUploadResponse* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.permalink_){}
+    , decltype(_impl_.status_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.permalink_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.permalink_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_permalink()) {
+    _this->_impl_.permalink_.Set(from._internal_permalink(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.status_ = from._impl_.status_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientUploadResponse)
+}
+
+inline void ClientUploadResponse::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.permalink_){}
+    , decltype(_impl_.status_){0}
+  };
+  _impl_.permalink_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.permalink_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientUploadResponse::~ClientUploadResponse() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientUploadResponse)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientUploadResponse::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.permalink_.Destroy();
+}
+
+void ClientUploadResponse::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientUploadResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientUploadResponse)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.permalink_.ClearNonDefaultToEmpty();
+  }
+  _impl_.status_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientUploadResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientUploadResponse_UploadStatus_IsValid(val))) {
+            _internal_set_status(static_cast<::safe_browsing::ClientUploadResponse_UploadStatus>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string permalink = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_permalink();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientUploadResponse::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientUploadResponse)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_status(), target);
+  }
+
+  // optional string permalink = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_permalink(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientUploadResponse)
+  return target;
+}
+
+size_t ClientUploadResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientUploadResponse)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string permalink = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_permalink());
+    }
+
+    // optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_status());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientUploadResponse::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientUploadResponse*>(
+      &from));
+}
+
+void ClientUploadResponse::MergeFrom(const ClientUploadResponse& from) {
+  ClientUploadResponse* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientUploadResponse)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_permalink(from._internal_permalink());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.status_ = from._impl_.status_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientUploadResponse::CopyFrom(const ClientUploadResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientUploadResponse)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientUploadResponse::IsInitialized() const {
+  return true;
+}
+
+void ClientUploadResponse::InternalSwap(ClientUploadResponse* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.permalink_, lhs_arena,
+      &other->_impl_.permalink_, rhs_arena
+  );
+  swap(_impl_.status_, other->_impl_.status_);
+}
+
+std::string ClientUploadResponse::GetTypeName() const {
+  return "safe_browsing.ClientUploadResponse";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_IncidentData_TrackedPreferenceIncident>()._impl_._has_bits_);
+  static void set_has_path(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_atomic_value(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_value_state(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ClientIncidentReport_IncidentData_TrackedPreferenceIncident(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+}
+ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ClientIncidentReport_IncidentData_TrackedPreferenceIncident(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.split_key_){from._impl_.split_key_}
+    , decltype(_impl_.path_){}
+    , decltype(_impl_.atomic_value_){}
+    , decltype(_impl_.value_state_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.path_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.path_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_path()) {
+    _this->_impl_.path_.Set(from._internal_path(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.atomic_value_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.atomic_value_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_atomic_value()) {
+    _this->_impl_.atomic_value_.Set(from._internal_atomic_value(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.value_state_ = from._impl_.value_state_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+}
+
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.split_key_){arena}
+    , decltype(_impl_.path_){}
+    , decltype(_impl_.atomic_value_){}
+    , decltype(_impl_.value_state_){0}
+  };
+  _impl_.path_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.path_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.atomic_value_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.atomic_value_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_IncidentData_TrackedPreferenceIncident::~ClientIncidentReport_IncidentData_TrackedPreferenceIncident() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.split_key_.~RepeatedPtrField();
+  _impl_.path_.Destroy();
+  _impl_.atomic_value_.Destroy();
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.split_key_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.path_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.atomic_value_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.value_state_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string path = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_path();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string atomic_value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_atomic_value();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string split_key = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_split_key();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.ValueState value_state = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_IsValid(val))) {
+            _internal_set_value_state(static_cast<::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string path = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_path(), target);
+  }
+
+  // optional string atomic_value = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_atomic_value(), target);
+  }
+
+  // repeated string split_key = 3;
+  for (int i = 0, n = this->_internal_split_key_size(); i < n; i++) {
+    const auto& s = this->_internal_split_key(i);
+    target = stream->WriteString(3, s, target);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.ValueState value_state = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_value_state(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+  return target;
+}
+
+size_t ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string split_key = 3;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.split_key_.size());
+  for (int i = 0, n = _impl_.split_key_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.split_key_.Get(i));
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string path = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_path());
+    }
+
+    // optional string atomic_value = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_atomic_value());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.ValueState value_state = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_value_state());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_IncidentData_TrackedPreferenceIncident*>(
+      &from));
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::MergeFrom(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from) {
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.split_key_.MergeFrom(from._impl_.split_key_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_path(from._internal_path());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_atomic_value(from._internal_atomic_value());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.value_state_ = from._impl_.value_state_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::CopyFrom(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::InternalSwap(ClientIncidentReport_IncidentData_TrackedPreferenceIncident* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.split_key_.InternalSwap(&other->_impl_.split_key_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.path_, lhs_arena,
+      &other->_impl_.path_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.atomic_value_, lhs_arena,
+      &other->_impl_.atomic_value_, rhs_arena
+  );
+  swap(_impl_.value_state_, other->_impl_.value_state_);
+}
+
+std::string ClientIncidentReport_IncidentData_TrackedPreferenceIncident::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile>()._impl_._has_bits_);
+  static void set_has_relative_path(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* msg);
+  static void set_has_signature(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* msg);
+  static void set_has_image_headers(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::safe_browsing::ClientDownloadRequest_SignatureInfo&
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_Internal::signature(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* msg) {
+  return *msg->_impl_.signature_;
+}
+const ::safe_browsing::ClientDownloadRequest_ImageHeaders&
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_Internal::image_headers(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* msg) {
+  return *msg->_impl_.image_headers_;
+}
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+}
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.relative_path_){}
+    , decltype(_impl_.signature_){nullptr}
+    , decltype(_impl_.image_headers_){nullptr}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.relative_path_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.relative_path_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_relative_path()) {
+    _this->_impl_.relative_path_.Set(from._internal_relative_path(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_signature()) {
+    _this->_impl_.signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo(*from._impl_.signature_);
+  }
+  if (from._internal_has_image_headers()) {
+    _this->_impl_.image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders(*from._impl_.image_headers_);
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+}
+
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.relative_path_){}
+    , decltype(_impl_.signature_){nullptr}
+    , decltype(_impl_.image_headers_){nullptr}
+  };
+  _impl_.relative_path_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.relative_path_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::~ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.relative_path_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.signature_;
+  if (this != internal_default_instance()) delete _impl_.image_headers_;
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.relative_path_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.signature_ != nullptr);
+      _impl_.signature_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.image_headers_ != nullptr);
+      _impl_.image_headers_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string relative_path = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_relative_path();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_signature(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_image_headers(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string relative_path = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_relative_path(), target);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::signature(this),
+        _Internal::signature(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::image_headers(this),
+        _Internal::image_headers(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+  return target;
+}
+
+size_t ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string relative_path = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_relative_path());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.signature_);
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.image_headers_);
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile*>(
+      &from));
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::MergeFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from) {
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_relative_path(from._internal_relative_path());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(
+          from._internal_signature());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(
+          from._internal_image_headers());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::CopyFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::IsInitialized() const {
+  if (_internal_has_signature()) {
+    if (!_impl_.signature_->IsInitialized()) return false;
+  }
+  if (_internal_has_image_headers()) {
+    if (!_impl_.image_headers_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::InternalSwap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.relative_path_, lhs_arena,
+      &other->_impl_.relative_path_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile, _impl_.image_headers_)
+      + sizeof(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_impl_.image_headers_)
+      - PROTOBUF_FIELD_OFFSET(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile, _impl_.signature_)>(
+          reinterpret_cast<char*>(&_impl_.signature_),
+          reinterpret_cast<char*>(&other->_impl_.signature_));
+}
+
+std::string ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_IncidentData_BinaryIntegrityIncident>()._impl_._has_bits_);
+  static void set_has_file_basename(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident* msg);
+  static void set_has_signature(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident* msg);
+  static void set_has_image_headers(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_sec_error(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::safe_browsing::ClientDownloadRequest_SignatureInfo&
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_Internal::signature(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident* msg) {
+  return *msg->_impl_.signature_;
+}
+const ::safe_browsing::ClientDownloadRequest_ImageHeaders&
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_Internal::image_headers(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident* msg) {
+  return *msg->_impl_.image_headers_;
+}
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident::ClientIncidentReport_IncidentData_BinaryIntegrityIncident(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+}
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident::ClientIncidentReport_IncidentData_BinaryIntegrityIncident(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.contained_file_){from._impl_.contained_file_}
+    , decltype(_impl_.file_basename_){}
+    , decltype(_impl_.signature_){nullptr}
+    , decltype(_impl_.image_headers_){nullptr}
+    , decltype(_impl_.sec_error_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.file_basename_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.file_basename_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_file_basename()) {
+    _this->_impl_.file_basename_.Set(from._internal_file_basename(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_signature()) {
+    _this->_impl_.signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo(*from._impl_.signature_);
+  }
+  if (from._internal_has_image_headers()) {
+    _this->_impl_.image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders(*from._impl_.image_headers_);
+  }
+  _this->_impl_.sec_error_ = from._impl_.sec_error_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+}
+
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.contained_file_){arena}
+    , decltype(_impl_.file_basename_){}
+    , decltype(_impl_.signature_){nullptr}
+    , decltype(_impl_.image_headers_){nullptr}
+    , decltype(_impl_.sec_error_){0}
+  };
+  _impl_.file_basename_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.file_basename_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident::~ClientIncidentReport_IncidentData_BinaryIntegrityIncident() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.contained_file_.~RepeatedPtrField();
+  _impl_.file_basename_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.signature_;
+  if (this != internal_default_instance()) delete _impl_.image_headers_;
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.contained_file_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.file_basename_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.signature_ != nullptr);
+      _impl_.signature_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.image_headers_ != nullptr);
+      _impl_.image_headers_->Clear();
+    }
+  }
+  _impl_.sec_error_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string file_basename = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_file_basename();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_signature(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_image_headers(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 sec_error = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_sec_error(&has_bits);
+          _impl_.sec_error_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile contained_file = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_contained_file(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string file_basename = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_file_basename(), target);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::signature(this),
+        _Internal::signature(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::image_headers(this),
+        _Internal::image_headers(this).GetCachedSize(), target, stream);
+  }
+
+  // optional int32 sec_error = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_sec_error(), target);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile contained_file = 5;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_contained_file_size()); i < n; i++) {
+    const auto& repfield = this->_internal_contained_file(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+  return target;
+}
+
+size_t ClientIncidentReport_IncidentData_BinaryIntegrityIncident::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile contained_file = 5;
+  total_size += 1UL * this->_internal_contained_file_size();
+  for (const auto& msg : this->_impl_.contained_file_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string file_basename = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_file_basename());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.signature_);
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.image_headers_);
+    }
+
+    // optional int32 sec_error = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_sec_error());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_IncidentData_BinaryIntegrityIncident*>(
+      &from));
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::MergeFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from) {
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.contained_file_.MergeFrom(from._impl_.contained_file_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_file_basename(from._internal_file_basename());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(
+          from._internal_signature());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(
+          from._internal_image_headers());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.sec_error_ = from._impl_.sec_error_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::CopyFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident::IsInitialized() const {
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.contained_file_))
+    return false;
+  if (_internal_has_signature()) {
+    if (!_impl_.signature_->IsInitialized()) return false;
+  }
+  if (_internal_has_image_headers()) {
+    if (!_impl_.image_headers_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::InternalSwap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.contained_file_.InternalSwap(&other->_impl_.contained_file_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.file_basename_, lhs_arena,
+      &other->_impl_.file_basename_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientIncidentReport_IncidentData_BinaryIntegrityIncident, _impl_.sec_error_)
+      + sizeof(ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_impl_.sec_error_)
+      - PROTOBUF_FIELD_OFFSET(ClientIncidentReport_IncidentData_BinaryIntegrityIncident, _impl_.signature_)>(
+          reinterpret_cast<char*>(&_impl_.signature_),
+          reinterpret_cast<char*>(&other->_impl_.signature_));
+}
+
+std::string ClientIncidentReport_IncidentData_BinaryIntegrityIncident::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_IncidentData_ResourceRequestIncident::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_IncidentData_ResourceRequestIncident>()._impl_._has_bits_);
+  static void set_has_digest(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_origin(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+ClientIncidentReport_IncidentData_ResourceRequestIncident::ClientIncidentReport_IncidentData_ResourceRequestIncident(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+}
+ClientIncidentReport_IncidentData_ResourceRequestIncident::ClientIncidentReport_IncidentData_ResourceRequestIncident(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_IncidentData_ResourceRequestIncident* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.digest_){}
+    , decltype(_impl_.origin_){}
+    , decltype(_impl_.type_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.digest_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.digest_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_digest()) {
+    _this->_impl_.digest_.Set(from._internal_digest(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.origin_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.origin_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_origin()) {
+    _this->_impl_.origin_.Set(from._internal_origin(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.type_ = from._impl_.type_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+}
+
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.digest_){}
+    , decltype(_impl_.origin_){}
+    , decltype(_impl_.type_){0}
+  };
+  _impl_.digest_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.digest_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.origin_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.origin_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_IncidentData_ResourceRequestIncident::~ClientIncidentReport_IncidentData_ResourceRequestIncident() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.digest_.Destroy();
+  _impl_.origin_.Destroy();
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.digest_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.origin_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.type_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_IncidentData_ResourceRequestIncident::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes digest = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_digest();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string origin = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_origin();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.Type type = 3 [default = UNKNOWN];
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_IsValid(val))) {
+            _internal_set_type(static_cast<::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_IncidentData_ResourceRequestIncident::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes digest = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_digest(), target);
+  }
+
+  // optional string origin = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_origin(), target);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.Type type = 3 [default = UNKNOWN];
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_type(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+  return target;
+}
+
+size_t ClientIncidentReport_IncidentData_ResourceRequestIncident::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional bytes digest = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_digest());
+    }
+
+    // optional string origin = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_origin());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.Type type = 3 [default = UNKNOWN];
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_IncidentData_ResourceRequestIncident*>(
+      &from));
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::MergeFrom(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from) {
+  ClientIncidentReport_IncidentData_ResourceRequestIncident* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_digest(from._internal_digest());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_origin(from._internal_origin());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.type_ = from._impl_.type_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::CopyFrom(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_IncidentData_ResourceRequestIncident::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::InternalSwap(ClientIncidentReport_IncidentData_ResourceRequestIncident* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.digest_, lhs_arena,
+      &other->_impl_.digest_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.origin_, lhs_arena,
+      &other->_impl_.origin_, rhs_arena
+  );
+  swap(_impl_.type_, other->_impl_.type_);
+}
+
+std::string ClientIncidentReport_IncidentData_ResourceRequestIncident::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_IncidentData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_IncidentData>()._impl_._has_bits_);
+  static void set_has_incident_time_msec(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident& tracked_preference(const ClientIncidentReport_IncidentData* msg);
+  static void set_has_tracked_preference(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident& binary_integrity(const ClientIncidentReport_IncidentData* msg);
+  static void set_has_binary_integrity(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident& resource_request(const ClientIncidentReport_IncidentData* msg);
+  static void set_has_resource_request(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident&
+ClientIncidentReport_IncidentData::_Internal::tracked_preference(const ClientIncidentReport_IncidentData* msg) {
+  return *msg->_impl_.tracked_preference_;
+}
+const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident&
+ClientIncidentReport_IncidentData::_Internal::binary_integrity(const ClientIncidentReport_IncidentData* msg) {
+  return *msg->_impl_.binary_integrity_;
+}
+const ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident&
+ClientIncidentReport_IncidentData::_Internal::resource_request(const ClientIncidentReport_IncidentData* msg) {
+  return *msg->_impl_.resource_request_;
+}
+ClientIncidentReport_IncidentData::ClientIncidentReport_IncidentData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.IncidentData)
+}
+ClientIncidentReport_IncidentData::ClientIncidentReport_IncidentData(const ClientIncidentReport_IncidentData& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_IncidentData* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.tracked_preference_){nullptr}
+    , decltype(_impl_.binary_integrity_){nullptr}
+    , decltype(_impl_.resource_request_){nullptr}
+    , decltype(_impl_.incident_time_msec_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  if (from._internal_has_tracked_preference()) {
+    _this->_impl_.tracked_preference_ = new ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident(*from._impl_.tracked_preference_);
+  }
+  if (from._internal_has_binary_integrity()) {
+    _this->_impl_.binary_integrity_ = new ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident(*from._impl_.binary_integrity_);
+  }
+  if (from._internal_has_resource_request()) {
+    _this->_impl_.resource_request_ = new ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident(*from._impl_.resource_request_);
+  }
+  _this->_impl_.incident_time_msec_ = from._impl_.incident_time_msec_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData)
+}
+
+inline void ClientIncidentReport_IncidentData::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.tracked_preference_){nullptr}
+    , decltype(_impl_.binary_integrity_){nullptr}
+    , decltype(_impl_.resource_request_){nullptr}
+    , decltype(_impl_.incident_time_msec_){int64_t{0}}
+  };
+}
+
+ClientIncidentReport_IncidentData::~ClientIncidentReport_IncidentData() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_IncidentData::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.tracked_preference_;
+  if (this != internal_default_instance()) delete _impl_.binary_integrity_;
+  if (this != internal_default_instance()) delete _impl_.resource_request_;
+}
+
+void ClientIncidentReport_IncidentData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_IncidentData::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.IncidentData)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.tracked_preference_ != nullptr);
+      _impl_.tracked_preference_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.binary_integrity_ != nullptr);
+      _impl_.binary_integrity_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.resource_request_ != nullptr);
+      _impl_.resource_request_->Clear();
+    }
+  }
+  _impl_.incident_time_msec_ = int64_t{0};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_IncidentData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional int64 incident_time_msec = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_incident_time_msec(&has_bits);
+          _impl_.incident_time_msec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident tracked_preference = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_tracked_preference(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident binary_integrity = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_binary_integrity(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident resource_request = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_resource_request(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_IncidentData::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.IncidentData)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int64 incident_time_msec = 1;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_incident_time_msec(), target);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident tracked_preference = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::tracked_preference(this),
+        _Internal::tracked_preference(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident binary_integrity = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::binary_integrity(this),
+        _Internal::binary_integrity(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident resource_request = 7;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(7, _Internal::resource_request(this),
+        _Internal::resource_request(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.IncidentData)
+  return target;
+}
+
+size_t ClientIncidentReport_IncidentData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.IncidentData)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident tracked_preference = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.tracked_preference_);
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident binary_integrity = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.binary_integrity_);
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident resource_request = 7;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.resource_request_);
+    }
+
+    // optional int64 incident_time_msec = 1;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_incident_time_msec());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_IncidentData::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_IncidentData*>(
+      &from));
+}
+
+void ClientIncidentReport_IncidentData::MergeFrom(const ClientIncidentReport_IncidentData& from) {
+  ClientIncidentReport_IncidentData* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.IncidentData)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_tracked_preference()->::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident::MergeFrom(
+          from._internal_tracked_preference());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_binary_integrity()->::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident::MergeFrom(
+          from._internal_binary_integrity());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_resource_request()->::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident::MergeFrom(
+          from._internal_resource_request());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.incident_time_msec_ = from._impl_.incident_time_msec_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_IncidentData::CopyFrom(const ClientIncidentReport_IncidentData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.IncidentData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_IncidentData::IsInitialized() const {
+  if (_internal_has_binary_integrity()) {
+    if (!_impl_.binary_integrity_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport_IncidentData::InternalSwap(ClientIncidentReport_IncidentData* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientIncidentReport_IncidentData, _impl_.incident_time_msec_)
+      + sizeof(ClientIncidentReport_IncidentData::_impl_.incident_time_msec_)
+      - PROTOBUF_FIELD_OFFSET(ClientIncidentReport_IncidentData, _impl_.tracked_preference_)>(
+          reinterpret_cast<char*>(&_impl_.tracked_preference_),
+          reinterpret_cast<char*>(&other->_impl_.tracked_preference_));
+}
+
+std::string ClientIncidentReport_IncidentData::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.IncidentData";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_DownloadDetails::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_DownloadDetails>()._impl_._has_bits_);
+  static void set_has_token(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::safe_browsing::ClientDownloadRequest& download(const ClientIncidentReport_DownloadDetails* msg);
+  static void set_has_download(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_download_time_msec(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_open_time_msec(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::safe_browsing::ClientDownloadRequest&
+ClientIncidentReport_DownloadDetails::_Internal::download(const ClientIncidentReport_DownloadDetails* msg) {
+  return *msg->_impl_.download_;
+}
+ClientIncidentReport_DownloadDetails::ClientIncidentReport_DownloadDetails(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.DownloadDetails)
+}
+ClientIncidentReport_DownloadDetails::ClientIncidentReport_DownloadDetails(const ClientIncidentReport_DownloadDetails& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_DownloadDetails* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.token_){}
+    , decltype(_impl_.download_){nullptr}
+    , decltype(_impl_.download_time_msec_){}
+    , decltype(_impl_.open_time_msec_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_token()) {
+    _this->_impl_.token_.Set(from._internal_token(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_download()) {
+    _this->_impl_.download_ = new ::safe_browsing::ClientDownloadRequest(*from._impl_.download_);
+  }
+  ::memcpy(&_impl_.download_time_msec_, &from._impl_.download_time_msec_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.open_time_msec_) -
+    reinterpret_cast<char*>(&_impl_.download_time_msec_)) + sizeof(_impl_.open_time_msec_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.DownloadDetails)
+}
+
+inline void ClientIncidentReport_DownloadDetails::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.token_){}
+    , decltype(_impl_.download_){nullptr}
+    , decltype(_impl_.download_time_msec_){int64_t{0}}
+    , decltype(_impl_.open_time_msec_){int64_t{0}}
+  };
+  _impl_.token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_DownloadDetails::~ClientIncidentReport_DownloadDetails() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.DownloadDetails)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_DownloadDetails::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.token_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.download_;
+}
+
+void ClientIncidentReport_DownloadDetails::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_DownloadDetails::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.DownloadDetails)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.token_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.download_ != nullptr);
+      _impl_.download_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000000cu) {
+    ::memset(&_impl_.download_time_msec_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.open_time_msec_) -
+        reinterpret_cast<char*>(&_impl_.download_time_msec_)) + sizeof(_impl_.open_time_msec_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_DownloadDetails::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes token = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_token();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest download = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_download(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 download_time_msec = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_download_time_msec(&has_bits);
+          _impl_.download_time_msec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 open_time_msec = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_open_time_msec(&has_bits);
+          _impl_.open_time_msec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_DownloadDetails::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.DownloadDetails)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes token = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_token(), target);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest download = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::download(this),
+        _Internal::download(this).GetCachedSize(), target, stream);
+  }
+
+  // optional int64 download_time_msec = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_download_time_msec(), target);
+  }
+
+  // optional int64 open_time_msec = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_open_time_msec(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.DownloadDetails)
+  return target;
+}
+
+size_t ClientIncidentReport_DownloadDetails::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.DownloadDetails)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional bytes token = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_token());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest download = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.download_);
+    }
+
+    // optional int64 download_time_msec = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_download_time_msec());
+    }
+
+    // optional int64 open_time_msec = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_open_time_msec());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_DownloadDetails::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_DownloadDetails*>(
+      &from));
+}
+
+void ClientIncidentReport_DownloadDetails::MergeFrom(const ClientIncidentReport_DownloadDetails& from) {
+  ClientIncidentReport_DownloadDetails* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.DownloadDetails)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_token(from._internal_token());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_download()->::safe_browsing::ClientDownloadRequest::MergeFrom(
+          from._internal_download());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.download_time_msec_ = from._impl_.download_time_msec_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.open_time_msec_ = from._impl_.open_time_msec_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_DownloadDetails::CopyFrom(const ClientIncidentReport_DownloadDetails& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.DownloadDetails)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_DownloadDetails::IsInitialized() const {
+  if (_internal_has_download()) {
+    if (!_impl_.download_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport_DownloadDetails::InternalSwap(ClientIncidentReport_DownloadDetails* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.token_, lhs_arena,
+      &other->_impl_.token_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientIncidentReport_DownloadDetails, _impl_.open_time_msec_)
+      + sizeof(ClientIncidentReport_DownloadDetails::_impl_.open_time_msec_)
+      - PROTOBUF_FIELD_OFFSET(ClientIncidentReport_DownloadDetails, _impl_.download_)>(
+          reinterpret_cast<char*>(&_impl_.download_),
+          reinterpret_cast<char*>(&other->_impl_.download_));
+}
+
+std::string ClientIncidentReport_DownloadDetails::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.DownloadDetails";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_EnvironmentData_OS_RegistryValue::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_OS_RegistryValue>()._impl_._has_bits_);
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_data(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ClientIncidentReport_EnvironmentData_OS_RegistryValue::ClientIncidentReport_EnvironmentData_OS_RegistryValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+}
+ClientIncidentReport_EnvironmentData_OS_RegistryValue::ClientIncidentReport_EnvironmentData_OS_RegistryValue(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_EnvironmentData_OS_RegistryValue* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.data_){}
+    , decltype(_impl_.type_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.data_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.data_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_data()) {
+    _this->_impl_.data_.Set(from._internal_data(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.type_ = from._impl_.type_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+}
+
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.data_){}
+    , decltype(_impl_.type_){0u}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.data_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.data_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_EnvironmentData_OS_RegistryValue::~ClientIncidentReport_EnvironmentData_OS_RegistryValue() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+  _impl_.data_.Destroy();
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.name_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.data_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.type_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_EnvironmentData_OS_RegistryValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 type = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_type(&has_bits);
+          _impl_.type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes data = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_data();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_EnvironmentData_OS_RegistryValue::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // optional uint32 type = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type(), target);
+  }
+
+  // optional bytes data = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_data(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+  return target;
+}
+
+size_t ClientIncidentReport_EnvironmentData_OS_RegistryValue::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string name = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_name());
+    }
+
+    // optional bytes data = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_data());
+    }
+
+    // optional uint32 type = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_type());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_EnvironmentData_OS_RegistryValue*>(
+      &from));
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::MergeFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from) {
+  ClientIncidentReport_EnvironmentData_OS_RegistryValue* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_data(from._internal_data());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.type_ = from._impl_.type_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::CopyFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_OS_RegistryValue::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::InternalSwap(ClientIncidentReport_EnvironmentData_OS_RegistryValue* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.data_, lhs_arena,
+      &other->_impl_.data_, rhs_arena
+  );
+  swap(_impl_.type_, other->_impl_.type_);
+}
+
+std::string ClientIncidentReport_EnvironmentData_OS_RegistryValue::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_EnvironmentData_OS_RegistryKey::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_OS_RegistryKey>()._impl_._has_bits_);
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+ClientIncidentReport_EnvironmentData_OS_RegistryKey::ClientIncidentReport_EnvironmentData_OS_RegistryKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+}
+ClientIncidentReport_EnvironmentData_OS_RegistryKey::ClientIncidentReport_EnvironmentData_OS_RegistryKey(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_EnvironmentData_OS_RegistryKey* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.value_){from._impl_.value_}
+    , decltype(_impl_.key_){from._impl_.key_}
+    , decltype(_impl_.name_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+}
+
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.value_){arena}
+    , decltype(_impl_.key_){arena}
+    , decltype(_impl_.name_){}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_EnvironmentData_OS_RegistryKey::~ClientIncidentReport_EnvironmentData_OS_RegistryKey() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.value_.~RepeatedPtrField();
+  _impl_.key_.~RepeatedPtrField();
+  _impl_.name_.Destroy();
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.value_.Clear();
+  _impl_.key_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.name_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_EnvironmentData_OS_RegistryKey::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_value(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey key = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_key(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_EnvironmentData_OS_RegistryKey::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue value = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_value_size()); i < n; i++) {
+    const auto& repfield = this->_internal_value(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey key = 3;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_key_size()); i < n; i++) {
+    const auto& repfield = this->_internal_key(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+  return target;
+}
+
+size_t ClientIncidentReport_EnvironmentData_OS_RegistryKey::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue value = 2;
+  total_size += 1UL * this->_internal_value_size();
+  for (const auto& msg : this->_impl_.value_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey key = 3;
+  total_size += 1UL * this->_internal_key_size();
+  for (const auto& msg : this->_impl_.key_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // optional string name = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_EnvironmentData_OS_RegistryKey*>(
+      &from));
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::MergeFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from) {
+  ClientIncidentReport_EnvironmentData_OS_RegistryKey* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.value_.MergeFrom(from._impl_.value_);
+  _this->_impl_.key_.MergeFrom(from._impl_.key_);
+  if (from._internal_has_name()) {
+    _this->_internal_set_name(from._internal_name());
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::CopyFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_OS_RegistryKey::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::InternalSwap(ClientIncidentReport_EnvironmentData_OS_RegistryKey* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.value_.InternalSwap(&other->_impl_.value_);
+  _impl_.key_.InternalSwap(&other->_impl_.key_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+}
+
+std::string ClientIncidentReport_EnvironmentData_OS_RegistryKey::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_EnvironmentData_OS::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_OS>()._impl_._has_bits_);
+  static void set_has_os_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_os_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_is_enrolled_to_domain(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+ClientIncidentReport_EnvironmentData_OS::ClientIncidentReport_EnvironmentData_OS(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+}
+ClientIncidentReport_EnvironmentData_OS::ClientIncidentReport_EnvironmentData_OS(const ClientIncidentReport_EnvironmentData_OS& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_EnvironmentData_OS* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.registry_key_){from._impl_.registry_key_}
+    , decltype(_impl_.os_name_){}
+    , decltype(_impl_.os_version_){}
+    , decltype(_impl_.is_enrolled_to_domain_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.os_name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.os_name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_os_name()) {
+    _this->_impl_.os_name_.Set(from._internal_os_name(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.os_version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.os_version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_os_version()) {
+    _this->_impl_.os_version_.Set(from._internal_os_version(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.is_enrolled_to_domain_ = from._impl_.is_enrolled_to_domain_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+}
+
+inline void ClientIncidentReport_EnvironmentData_OS::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.registry_key_){arena}
+    , decltype(_impl_.os_name_){}
+    , decltype(_impl_.os_version_){}
+    , decltype(_impl_.is_enrolled_to_domain_){false}
+  };
+  _impl_.os_name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.os_name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.os_version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.os_version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_EnvironmentData_OS::~ClientIncidentReport_EnvironmentData_OS() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_EnvironmentData_OS::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.registry_key_.~RepeatedPtrField();
+  _impl_.os_name_.Destroy();
+  _impl_.os_version_.Destroy();
+}
+
+void ClientIncidentReport_EnvironmentData_OS::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_EnvironmentData_OS::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.registry_key_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.os_name_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.os_version_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.is_enrolled_to_domain_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_EnvironmentData_OS::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string os_name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_os_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string os_version = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_os_version();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey registry_key = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_registry_key(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool is_enrolled_to_domain = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_is_enrolled_to_domain(&has_bits);
+          _impl_.is_enrolled_to_domain_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_EnvironmentData_OS::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string os_name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_os_name(), target);
+  }
+
+  // optional string os_version = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_os_version(), target);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey registry_key = 3;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_registry_key_size()); i < n; i++) {
+    const auto& repfield = this->_internal_registry_key(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional bool is_enrolled_to_domain = 4;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_is_enrolled_to_domain(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+  return target;
+}
+
+size_t ClientIncidentReport_EnvironmentData_OS::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey registry_key = 3;
+  total_size += 1UL * this->_internal_registry_key_size();
+  for (const auto& msg : this->_impl_.registry_key_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string os_name = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_os_name());
+    }
+
+    // optional string os_version = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_os_version());
+    }
+
+    // optional bool is_enrolled_to_domain = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_OS::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_EnvironmentData_OS*>(
+      &from));
+}
+
+void ClientIncidentReport_EnvironmentData_OS::MergeFrom(const ClientIncidentReport_EnvironmentData_OS& from) {
+  ClientIncidentReport_EnvironmentData_OS* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.registry_key_.MergeFrom(from._impl_.registry_key_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_os_name(from._internal_os_name());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_os_version(from._internal_os_version());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.is_enrolled_to_domain_ = from._impl_.is_enrolled_to_domain_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_EnvironmentData_OS::CopyFrom(const ClientIncidentReport_EnvironmentData_OS& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_OS::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_OS::InternalSwap(ClientIncidentReport_EnvironmentData_OS* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.registry_key_.InternalSwap(&other->_impl_.registry_key_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.os_name_, lhs_arena,
+      &other->_impl_.os_name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.os_version_, lhs_arena,
+      &other->_impl_.os_version_, rhs_arena
+  );
+  swap(_impl_.is_enrolled_to_domain_, other->_impl_.is_enrolled_to_domain_);
+}
+
+std::string ClientIncidentReport_EnvironmentData_OS::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.OS";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_EnvironmentData_Machine::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_Machine>()._impl_._has_bits_);
+  static void set_has_cpu_architecture(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_cpu_vendor(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_cpuid(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+ClientIncidentReport_EnvironmentData_Machine::ClientIncidentReport_EnvironmentData_Machine(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+}
+ClientIncidentReport_EnvironmentData_Machine::ClientIncidentReport_EnvironmentData_Machine(const ClientIncidentReport_EnvironmentData_Machine& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_EnvironmentData_Machine* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.cpu_architecture_){}
+    , decltype(_impl_.cpu_vendor_){}
+    , decltype(_impl_.cpuid_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.cpu_architecture_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.cpu_architecture_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_cpu_architecture()) {
+    _this->_impl_.cpu_architecture_.Set(from._internal_cpu_architecture(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.cpu_vendor_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.cpu_vendor_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_cpu_vendor()) {
+    _this->_impl_.cpu_vendor_.Set(from._internal_cpu_vendor(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.cpuid_ = from._impl_.cpuid_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+}
+
+inline void ClientIncidentReport_EnvironmentData_Machine::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.cpu_architecture_){}
+    , decltype(_impl_.cpu_vendor_){}
+    , decltype(_impl_.cpuid_){0u}
+  };
+  _impl_.cpu_architecture_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.cpu_architecture_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.cpu_vendor_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.cpu_vendor_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_EnvironmentData_Machine::~ClientIncidentReport_EnvironmentData_Machine() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_EnvironmentData_Machine::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.cpu_architecture_.Destroy();
+  _impl_.cpu_vendor_.Destroy();
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.cpu_architecture_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.cpu_vendor_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.cpuid_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_EnvironmentData_Machine::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string cpu_architecture = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_cpu_architecture();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string cpu_vendor = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_cpu_vendor();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 cpuid = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_cpuid(&has_bits);
+          _impl_.cpuid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_EnvironmentData_Machine::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string cpu_architecture = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_cpu_architecture(), target);
+  }
+
+  // optional string cpu_vendor = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_cpu_vendor(), target);
+  }
+
+  // optional uint32 cpuid = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_cpuid(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+  return target;
+}
+
+size_t ClientIncidentReport_EnvironmentData_Machine::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string cpu_architecture = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_cpu_architecture());
+    }
+
+    // optional string cpu_vendor = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_cpu_vendor());
+    }
+
+    // optional uint32 cpuid = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_cpuid());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_EnvironmentData_Machine*>(
+      &from));
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::MergeFrom(const ClientIncidentReport_EnvironmentData_Machine& from) {
+  ClientIncidentReport_EnvironmentData_Machine* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_cpu_architecture(from._internal_cpu_architecture());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_cpu_vendor(from._internal_cpu_vendor());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.cpuid_ = from._impl_.cpuid_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::CopyFrom(const ClientIncidentReport_EnvironmentData_Machine& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Machine::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::InternalSwap(ClientIncidentReport_EnvironmentData_Machine* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.cpu_architecture_, lhs_arena,
+      &other->_impl_.cpu_architecture_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.cpu_vendor_, lhs_arena,
+      &other->_impl_.cpu_vendor_, rhs_arena
+  );
+  swap(_impl_.cpuid_, other->_impl_.cpuid_);
+}
+
+std::string ClientIncidentReport_EnvironmentData_Machine::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Machine";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_EnvironmentData_Process_Patch::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_Process_Patch>()._impl_._has_bits_);
+  static void set_has_function(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_target_dll(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ClientIncidentReport_EnvironmentData_Process_Patch::ClientIncidentReport_EnvironmentData_Process_Patch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+}
+ClientIncidentReport_EnvironmentData_Process_Patch::ClientIncidentReport_EnvironmentData_Process_Patch(const ClientIncidentReport_EnvironmentData_Process_Patch& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_EnvironmentData_Process_Patch* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.function_){}
+    , decltype(_impl_.target_dll_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.function_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.function_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_function()) {
+    _this->_impl_.function_.Set(from._internal_function(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.target_dll_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.target_dll_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_target_dll()) {
+    _this->_impl_.target_dll_.Set(from._internal_target_dll(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+}
+
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.function_){}
+    , decltype(_impl_.target_dll_){}
+  };
+  _impl_.function_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.function_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.target_dll_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.target_dll_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_EnvironmentData_Process_Patch::~ClientIncidentReport_EnvironmentData_Process_Patch() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.function_.Destroy();
+  _impl_.target_dll_.Destroy();
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.function_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.target_dll_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_EnvironmentData_Process_Patch::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string function = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_function();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string target_dll = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_target_dll();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_EnvironmentData_Process_Patch::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string function = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_function(), target);
+  }
+
+  // optional string target_dll = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_target_dll(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+  return target;
+}
+
+size_t ClientIncidentReport_EnvironmentData_Process_Patch::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string function = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_function());
+    }
+
+    // optional string target_dll = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_target_dll());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_EnvironmentData_Process_Patch*>(
+      &from));
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_Patch& from) {
+  ClientIncidentReport_EnvironmentData_Process_Patch* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_function(from._internal_function());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_target_dll(from._internal_target_dll());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::CopyFrom(const ClientIncidentReport_EnvironmentData_Process_Patch& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_Patch::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::InternalSwap(ClientIncidentReport_EnvironmentData_Process_Patch* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.function_, lhs_arena,
+      &other->_impl_.function_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.target_dll_, lhs_arena,
+      &other->_impl_.target_dll_, rhs_arena
+  );
+}
+
+std::string ClientIncidentReport_EnvironmentData_Process_Patch::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_EnvironmentData_Process_NetworkProvider::_Internal {
+ public:
+};
+
+ClientIncidentReport_EnvironmentData_Process_NetworkProvider::ClientIncidentReport_EnvironmentData_Process_NetworkProvider(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+}
+ClientIncidentReport_EnvironmentData_Process_NetworkProvider::ClientIncidentReport_EnvironmentData_Process_NetworkProvider(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_EnvironmentData_Process_NetworkProvider* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      /*decltype(_impl_._cached_size_)*/{}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+}
+
+inline void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      /*decltype(_impl_._cached_size_)*/{}
+  };
+}
+
+ClientIncidentReport_EnvironmentData_Process_NetworkProvider::~ClientIncidentReport_EnvironmentData_Process_NetworkProvider() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_EnvironmentData_Process_NetworkProvider::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_EnvironmentData_Process_NetworkProvider::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+  return target;
+}
+
+size_t ClientIncidentReport_EnvironmentData_Process_NetworkProvider::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_EnvironmentData_Process_NetworkProvider*>(
+      &from));
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from) {
+  ClientIncidentReport_EnvironmentData_Process_NetworkProvider* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::CopyFrom(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_NetworkProvider::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::InternalSwap(ClientIncidentReport_EnvironmentData_Process_NetworkProvider* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+}
+
+std::string ClientIncidentReport_EnvironmentData_Process_NetworkProvider::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_EnvironmentData_Process_Dll::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_Process_Dll>()._impl_._has_bits_);
+  static void set_has_path(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_base_address(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_length(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers(const ClientIncidentReport_EnvironmentData_Process_Dll* msg);
+  static void set_has_image_headers(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::safe_browsing::ClientDownloadRequest_ImageHeaders&
+ClientIncidentReport_EnvironmentData_Process_Dll::_Internal::image_headers(const ClientIncidentReport_EnvironmentData_Process_Dll* msg) {
+  return *msg->_impl_.image_headers_;
+}
+ClientIncidentReport_EnvironmentData_Process_Dll::ClientIncidentReport_EnvironmentData_Process_Dll(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+}
+ClientIncidentReport_EnvironmentData_Process_Dll::ClientIncidentReport_EnvironmentData_Process_Dll(const ClientIncidentReport_EnvironmentData_Process_Dll& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_EnvironmentData_Process_Dll* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.feature_){from._impl_.feature_}
+    , decltype(_impl_.path_){}
+    , decltype(_impl_.image_headers_){nullptr}
+    , decltype(_impl_.base_address_){}
+    , decltype(_impl_.length_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.path_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.path_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_path()) {
+    _this->_impl_.path_.Set(from._internal_path(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_image_headers()) {
+    _this->_impl_.image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders(*from._impl_.image_headers_);
+  }
+  ::memcpy(&_impl_.base_address_, &from._impl_.base_address_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.length_) -
+    reinterpret_cast<char*>(&_impl_.base_address_)) + sizeof(_impl_.length_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+}
+
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.feature_){arena}
+    , decltype(_impl_.path_){}
+    , decltype(_impl_.image_headers_){nullptr}
+    , decltype(_impl_.base_address_){uint64_t{0u}}
+    , decltype(_impl_.length_){0u}
+  };
+  _impl_.path_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.path_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_EnvironmentData_Process_Dll::~ClientIncidentReport_EnvironmentData_Process_Dll() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.feature_.~RepeatedField();
+  _impl_.path_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.image_headers_;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.feature_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.path_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.image_headers_ != nullptr);
+      _impl_.image_headers_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x0000000cu) {
+    ::memset(&_impl_.base_address_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.length_) -
+        reinterpret_cast<char*>(&_impl_.base_address_)) + sizeof(_impl_.length_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_EnvironmentData_Process_Dll::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string path = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_path();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint64 base_address = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_base_address(&has_bits);
+          _impl_.base_address_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional uint32 length = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_length(&has_bits);
+          _impl_.length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.Feature feature = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+            CHK_(ptr);
+            if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature_IsValid(val))) {
+              _internal_add_feature(static_cast<::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature>(val));
+            } else {
+              ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
+            }
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr));
+        } else if (static_cast<uint8_t>(tag) == 34) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<std::string>(_internal_mutable_feature(), ptr, ctx, ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature_IsValid, &_internal_metadata_, 4);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_image_headers(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_EnvironmentData_Process_Dll::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string path = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_path(), target);
+  }
+
+  // optional uint64 base_address = 2;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_base_address(), target);
+  }
+
+  // optional uint32 length = 3;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_length(), target);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.Feature feature = 4;
+  for (int i = 0, n = this->_internal_feature_size(); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+        4, this->_internal_feature(i), target);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(5, _Internal::image_headers(this),
+        _Internal::image_headers(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+  return target;
+}
+
+size_t ClientIncidentReport_EnvironmentData_Process_Dll::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.Feature feature = 4;
+  {
+    size_t data_size = 0;
+    unsigned int count = static_cast<unsigned int>(this->_internal_feature_size());for (unsigned int i = 0; i < count; i++) {
+      data_size += ::_pbi::WireFormatLite::EnumSize(
+        this->_internal_feature(static_cast<int>(i)));
+    }
+    total_size += (1UL * count) + data_size;
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string path = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_path());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.image_headers_);
+    }
+
+    // optional uint64 base_address = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_base_address());
+    }
+
+    // optional uint32 length = 3;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_length());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_EnvironmentData_Process_Dll*>(
+      &from));
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_Dll& from) {
+  ClientIncidentReport_EnvironmentData_Process_Dll* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.feature_.MergeFrom(from._impl_.feature_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_path(from._internal_path());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(
+          from._internal_image_headers());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.base_address_ = from._impl_.base_address_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.length_ = from._impl_.length_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::CopyFrom(const ClientIncidentReport_EnvironmentData_Process_Dll& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_Dll::IsInitialized() const {
+  if (_internal_has_image_headers()) {
+    if (!_impl_.image_headers_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::InternalSwap(ClientIncidentReport_EnvironmentData_Process_Dll* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.feature_.InternalSwap(&other->_impl_.feature_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.path_, lhs_arena,
+      &other->_impl_.path_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientIncidentReport_EnvironmentData_Process_Dll, _impl_.length_)
+      + sizeof(ClientIncidentReport_EnvironmentData_Process_Dll::_impl_.length_)
+      - PROTOBUF_FIELD_OFFSET(ClientIncidentReport_EnvironmentData_Process_Dll, _impl_.image_headers_)>(
+          reinterpret_cast<char*>(&_impl_.image_headers_),
+          reinterpret_cast<char*>(&other->_impl_.image_headers_));
+}
+
+std::string ClientIncidentReport_EnvironmentData_Process_Dll::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification>()._impl_._has_bits_);
+  static void set_has_file_offset(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_byte_count(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_modified_bytes(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_export_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+}
+ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.modified_bytes_){}
+    , decltype(_impl_.export_name_){}
+    , decltype(_impl_.file_offset_){}
+    , decltype(_impl_.byte_count_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.modified_bytes_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.modified_bytes_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_modified_bytes()) {
+    _this->_impl_.modified_bytes_.Set(from._internal_modified_bytes(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.export_name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.export_name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_export_name()) {
+    _this->_impl_.export_name_.Set(from._internal_export_name(),
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.file_offset_, &from._impl_.file_offset_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.byte_count_) -
+    reinterpret_cast<char*>(&_impl_.file_offset_)) + sizeof(_impl_.byte_count_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+}
+
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.modified_bytes_){}
+    , decltype(_impl_.export_name_){}
+    , decltype(_impl_.file_offset_){0u}
+    , decltype(_impl_.byte_count_){0}
+  };
+  _impl_.modified_bytes_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.modified_bytes_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.export_name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.export_name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::~ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.modified_bytes_.Destroy();
+  _impl_.export_name_.Destroy();
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.modified_bytes_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.export_name_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x0000000cu) {
+    ::memset(&_impl_.file_offset_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.byte_count_) -
+        reinterpret_cast<char*>(&_impl_.file_offset_)) + sizeof(_impl_.byte_count_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 file_offset = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_file_offset(&has_bits);
+          _impl_.file_offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 byte_count = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_byte_count(&has_bits);
+          _impl_.byte_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes modified_bytes = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_modified_bytes();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string export_name = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_export_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 file_offset = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_file_offset(), target);
+  }
+
+  // optional int32 byte_count = 2;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_byte_count(), target);
+  }
+
+  // optional bytes modified_bytes = 3;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_modified_bytes(), target);
+  }
+
+  // optional string export_name = 4;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_export_name(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+  return target;
+}
+
+size_t ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional bytes modified_bytes = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_modified_bytes());
+    }
+
+    // optional string export_name = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_export_name());
+    }
+
+    // optional uint32 file_offset = 1;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_file_offset());
+    }
+
+    // optional int32 byte_count = 2;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_byte_count());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification*>(
+      &from));
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from) {
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_modified_bytes(from._internal_modified_bytes());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_export_name(from._internal_export_name());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.file_offset_ = from._impl_.file_offset_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.byte_count_ = from._impl_.byte_count_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::CopyFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::InternalSwap(ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.modified_bytes_, lhs_arena,
+      &other->_impl_.modified_bytes_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.export_name_, lhs_arena,
+      &other->_impl_.export_name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification, _impl_.byte_count_)
+      + sizeof(ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_impl_.byte_count_)
+      - PROTOBUF_FIELD_OFFSET(ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification, _impl_.file_offset_)>(
+          reinterpret_cast<char*>(&_impl_.file_offset_),
+          reinterpret_cast<char*>(&other->_impl_.file_offset_));
+}
+
+std::string ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_EnvironmentData_Process_ModuleState::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_Process_ModuleState>()._impl_._has_bits_);
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_modified_state(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ClientIncidentReport_EnvironmentData_Process_ModuleState::ClientIncidentReport_EnvironmentData_Process_ModuleState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+}
+ClientIncidentReport_EnvironmentData_Process_ModuleState::ClientIncidentReport_EnvironmentData_Process_ModuleState(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_EnvironmentData_Process_ModuleState* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.obsolete_modified_export_){from._impl_.obsolete_modified_export_}
+    , decltype(_impl_.modification_){from._impl_.modification_}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.modified_state_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.modified_state_ = from._impl_.modified_state_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+}
+
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.obsolete_modified_export_){arena}
+    , decltype(_impl_.modification_){arena}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.modified_state_){0}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_EnvironmentData_Process_ModuleState::~ClientIncidentReport_EnvironmentData_Process_ModuleState() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.obsolete_modified_export_.~RepeatedPtrField();
+  _impl_.modification_.~RepeatedPtrField();
+  _impl_.name_.Destroy();
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.obsolete_modified_export_.Clear();
+  _impl_.modification_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.name_.ClearNonDefaultToEmpty();
+  }
+  _impl_.modified_state_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_EnvironmentData_Process_ModuleState::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.ModifiedState modified_state = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_IsValid(val))) {
+            _internal_set_modified_state(static_cast<::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string OBSOLETE_modified_export = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_obsolete_modified_export();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification modification = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_modification(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_EnvironmentData_Process_ModuleState::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.ModifiedState modified_state = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_modified_state(), target);
+  }
+
+  // repeated string OBSOLETE_modified_export = 3;
+  for (int i = 0, n = this->_internal_obsolete_modified_export_size(); i < n; i++) {
+    const auto& s = this->_internal_obsolete_modified_export(i);
+    target = stream->WriteString(3, s, target);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification modification = 4;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_modification_size()); i < n; i++) {
+    const auto& repfield = this->_internal_modification(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+  return target;
+}
+
+size_t ClientIncidentReport_EnvironmentData_Process_ModuleState::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string OBSOLETE_modified_export = 3;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.obsolete_modified_export_.size());
+  for (int i = 0, n = _impl_.obsolete_modified_export_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.obsolete_modified_export_.Get(i));
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification modification = 4;
+  total_size += 1UL * this->_internal_modification_size();
+  for (const auto& msg : this->_impl_.modification_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string name = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_name());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.ModifiedState modified_state = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_modified_state());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_EnvironmentData_Process_ModuleState*>(
+      &from));
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from) {
+  ClientIncidentReport_EnvironmentData_Process_ModuleState* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.obsolete_modified_export_.MergeFrom(from._impl_.obsolete_modified_export_);
+  _this->_impl_.modification_.MergeFrom(from._impl_.modification_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.modified_state_ = from._impl_.modified_state_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::CopyFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_ModuleState::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::InternalSwap(ClientIncidentReport_EnvironmentData_Process_ModuleState* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.obsolete_modified_export_.InternalSwap(&other->_impl_.obsolete_modified_export_);
+  _impl_.modification_.InternalSwap(&other->_impl_.modification_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  swap(_impl_.modified_state_, other->_impl_.modified_state_);
+}
+
+std::string ClientIncidentReport_EnvironmentData_Process_ModuleState::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_EnvironmentData_Process::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_Process>()._impl_._has_bits_);
+  static void set_has_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_chrome_update_channel(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_uptime_msec(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_metrics_consent(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_obsolete_extended_consent(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_obsolete_field_trial_participant(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+};
+
+ClientIncidentReport_EnvironmentData_Process::ClientIncidentReport_EnvironmentData_Process(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+}
+ClientIncidentReport_EnvironmentData_Process::ClientIncidentReport_EnvironmentData_Process(const ClientIncidentReport_EnvironmentData_Process& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_EnvironmentData_Process* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.obsolete_dlls_){from._impl_.obsolete_dlls_}
+    , decltype(_impl_.patches_){from._impl_.patches_}
+    , decltype(_impl_.network_providers_){from._impl_.network_providers_}
+    , decltype(_impl_.dll_){from._impl_.dll_}
+    , decltype(_impl_.blacklisted_dll_){from._impl_.blacklisted_dll_}
+    , decltype(_impl_.module_state_){from._impl_.module_state_}
+    , decltype(_impl_.version_){}
+    , decltype(_impl_.uptime_msec_){}
+    , decltype(_impl_.chrome_update_channel_){}
+    , decltype(_impl_.metrics_consent_){}
+    , decltype(_impl_.obsolete_extended_consent_){}
+    , decltype(_impl_.obsolete_field_trial_participant_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_version()) {
+    _this->_impl_.version_.Set(from._internal_version(),
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.uptime_msec_, &from._impl_.uptime_msec_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.obsolete_field_trial_participant_) -
+    reinterpret_cast<char*>(&_impl_.uptime_msec_)) + sizeof(_impl_.obsolete_field_trial_participant_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+}
+
+inline void ClientIncidentReport_EnvironmentData_Process::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.obsolete_dlls_){arena}
+    , decltype(_impl_.patches_){arena}
+    , decltype(_impl_.network_providers_){arena}
+    , decltype(_impl_.dll_){arena}
+    , decltype(_impl_.blacklisted_dll_){arena}
+    , decltype(_impl_.module_state_){arena}
+    , decltype(_impl_.version_){}
+    , decltype(_impl_.uptime_msec_){int64_t{0}}
+    , decltype(_impl_.chrome_update_channel_){0}
+    , decltype(_impl_.metrics_consent_){false}
+    , decltype(_impl_.obsolete_extended_consent_){false}
+    , decltype(_impl_.obsolete_field_trial_participant_){false}
+  };
+  _impl_.version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_EnvironmentData_Process::~ClientIncidentReport_EnvironmentData_Process() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_EnvironmentData_Process::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.obsolete_dlls_.~RepeatedPtrField();
+  _impl_.patches_.~RepeatedPtrField();
+  _impl_.network_providers_.~RepeatedPtrField();
+  _impl_.dll_.~RepeatedPtrField();
+  _impl_.blacklisted_dll_.~RepeatedPtrField();
+  _impl_.module_state_.~RepeatedPtrField();
+  _impl_.version_.Destroy();
+}
+
+void ClientIncidentReport_EnvironmentData_Process::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_EnvironmentData_Process::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.obsolete_dlls_.Clear();
+  _impl_.patches_.Clear();
+  _impl_.network_providers_.Clear();
+  _impl_.dll_.Clear();
+  _impl_.blacklisted_dll_.Clear();
+  _impl_.module_state_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.version_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x0000003eu) {
+    ::memset(&_impl_.uptime_msec_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.obsolete_field_trial_participant_) -
+        reinterpret_cast<char*>(&_impl_.uptime_msec_)) + sizeof(_impl_.obsolete_field_trial_participant_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_EnvironmentData_Process::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string version = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_version();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string OBSOLETE_dlls = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_obsolete_dlls();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch patches = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_patches(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider network_providers = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_network_providers(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Channel chrome_update_channel = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel_IsValid(val))) {
+            _internal_set_chrome_update_channel(static_cast<::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 uptime_msec = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_uptime_msec(&has_bits);
+          _impl_.uptime_msec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool metrics_consent = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _Internal::set_has_metrics_consent(&has_bits);
+          _impl_.metrics_consent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool OBSOLETE_extended_consent = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_obsolete_extended_consent(&has_bits);
+          _impl_.obsolete_extended_consent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll dll = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_dll(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string blacklisted_dll = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_blacklisted_dll();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState module_state = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_module_state(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool OBSOLETE_field_trial_participant = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          _Internal::set_has_obsolete_field_trial_participant(&has_bits);
+          _impl_.obsolete_field_trial_participant_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_EnvironmentData_Process::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string version = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_version(), target);
+  }
+
+  // repeated string OBSOLETE_dlls = 2;
+  for (int i = 0, n = this->_internal_obsolete_dlls_size(); i < n; i++) {
+    const auto& s = this->_internal_obsolete_dlls(i);
+    target = stream->WriteString(2, s, target);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch patches = 3;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_patches_size()); i < n; i++) {
+    const auto& repfield = this->_internal_patches(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider network_providers = 4;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_network_providers_size()); i < n; i++) {
+    const auto& repfield = this->_internal_network_providers(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Channel chrome_update_channel = 5;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      5, this->_internal_chrome_update_channel(), target);
+  }
+
+  // optional int64 uptime_msec = 6;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(6, this->_internal_uptime_msec(), target);
+  }
+
+  // optional bool metrics_consent = 7;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_metrics_consent(), target);
+  }
+
+  // optional bool OBSOLETE_extended_consent = 8;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_obsolete_extended_consent(), target);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll dll = 9;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_dll_size()); i < n; i++) {
+    const auto& repfield = this->_internal_dll(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(9, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // repeated string blacklisted_dll = 10;
+  for (int i = 0, n = this->_internal_blacklisted_dll_size(); i < n; i++) {
+    const auto& s = this->_internal_blacklisted_dll(i);
+    target = stream->WriteString(10, s, target);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState module_state = 11;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_module_state_size()); i < n; i++) {
+    const auto& repfield = this->_internal_module_state(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(11, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional bool OBSOLETE_field_trial_participant = 12;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(12, this->_internal_obsolete_field_trial_participant(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+  return target;
+}
+
+size_t ClientIncidentReport_EnvironmentData_Process::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string OBSOLETE_dlls = 2;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.obsolete_dlls_.size());
+  for (int i = 0, n = _impl_.obsolete_dlls_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.obsolete_dlls_.Get(i));
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch patches = 3;
+  total_size += 1UL * this->_internal_patches_size();
+  for (const auto& msg : this->_impl_.patches_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider network_providers = 4;
+  total_size += 1UL * this->_internal_network_providers_size();
+  for (const auto& msg : this->_impl_.network_providers_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll dll = 9;
+  total_size += 1UL * this->_internal_dll_size();
+  for (const auto& msg : this->_impl_.dll_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated string blacklisted_dll = 10;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.blacklisted_dll_.size());
+  for (int i = 0, n = _impl_.blacklisted_dll_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.blacklisted_dll_.Get(i));
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState module_state = 11;
+  total_size += 1UL * this->_internal_module_state_size();
+  for (const auto& msg : this->_impl_.module_state_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    // optional string version = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_version());
+    }
+
+    // optional int64 uptime_msec = 6;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_uptime_msec());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Channel chrome_update_channel = 5;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_chrome_update_channel());
+    }
+
+    // optional bool metrics_consent = 7;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool OBSOLETE_extended_consent = 8;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool OBSOLETE_field_trial_participant = 12;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Process::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_EnvironmentData_Process*>(
+      &from));
+}
+
+void ClientIncidentReport_EnvironmentData_Process::MergeFrom(const ClientIncidentReport_EnvironmentData_Process& from) {
+  ClientIncidentReport_EnvironmentData_Process* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.obsolete_dlls_.MergeFrom(from._impl_.obsolete_dlls_);
+  _this->_impl_.patches_.MergeFrom(from._impl_.patches_);
+  _this->_impl_.network_providers_.MergeFrom(from._impl_.network_providers_);
+  _this->_impl_.dll_.MergeFrom(from._impl_.dll_);
+  _this->_impl_.blacklisted_dll_.MergeFrom(from._impl_.blacklisted_dll_);
+  _this->_impl_.module_state_.MergeFrom(from._impl_.module_state_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_version(from._internal_version());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.uptime_msec_ = from._impl_.uptime_msec_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.chrome_update_channel_ = from._impl_.chrome_update_channel_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.metrics_consent_ = from._impl_.metrics_consent_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.obsolete_extended_consent_ = from._impl_.obsolete_extended_consent_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.obsolete_field_trial_participant_ = from._impl_.obsolete_field_trial_participant_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_EnvironmentData_Process::CopyFrom(const ClientIncidentReport_EnvironmentData_Process& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Process::IsInitialized() const {
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.dll_))
+    return false;
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Process::InternalSwap(ClientIncidentReport_EnvironmentData_Process* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.obsolete_dlls_.InternalSwap(&other->_impl_.obsolete_dlls_);
+  _impl_.patches_.InternalSwap(&other->_impl_.patches_);
+  _impl_.network_providers_.InternalSwap(&other->_impl_.network_providers_);
+  _impl_.dll_.InternalSwap(&other->_impl_.dll_);
+  _impl_.blacklisted_dll_.InternalSwap(&other->_impl_.blacklisted_dll_);
+  _impl_.module_state_.InternalSwap(&other->_impl_.module_state_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.version_, lhs_arena,
+      &other->_impl_.version_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientIncidentReport_EnvironmentData_Process, _impl_.obsolete_field_trial_participant_)
+      + sizeof(ClientIncidentReport_EnvironmentData_Process::_impl_.obsolete_field_trial_participant_)
+      - PROTOBUF_FIELD_OFFSET(ClientIncidentReport_EnvironmentData_Process, _impl_.uptime_msec_)>(
+          reinterpret_cast<char*>(&_impl_.uptime_msec_),
+          reinterpret_cast<char*>(&other->_impl_.uptime_msec_));
+}
+
+std::string ClientIncidentReport_EnvironmentData_Process::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Process";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_EnvironmentData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData>()._impl_._has_bits_);
+  static const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS& os(const ClientIncidentReport_EnvironmentData* msg);
+  static void set_has_os(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine& machine(const ClientIncidentReport_EnvironmentData* msg);
+  static void set_has_machine(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process& process(const ClientIncidentReport_EnvironmentData* msg);
+  static void set_has_process(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS&
+ClientIncidentReport_EnvironmentData::_Internal::os(const ClientIncidentReport_EnvironmentData* msg) {
+  return *msg->_impl_.os_;
+}
+const ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine&
+ClientIncidentReport_EnvironmentData::_Internal::machine(const ClientIncidentReport_EnvironmentData* msg) {
+  return *msg->_impl_.machine_;
+}
+const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process&
+ClientIncidentReport_EnvironmentData::_Internal::process(const ClientIncidentReport_EnvironmentData* msg) {
+  return *msg->_impl_.process_;
+}
+ClientIncidentReport_EnvironmentData::ClientIncidentReport_EnvironmentData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.EnvironmentData)
+}
+ClientIncidentReport_EnvironmentData::ClientIncidentReport_EnvironmentData(const ClientIncidentReport_EnvironmentData& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_EnvironmentData* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.os_){nullptr}
+    , decltype(_impl_.machine_){nullptr}
+    , decltype(_impl_.process_){nullptr}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  if (from._internal_has_os()) {
+    _this->_impl_.os_ = new ::safe_browsing::ClientIncidentReport_EnvironmentData_OS(*from._impl_.os_);
+  }
+  if (from._internal_has_machine()) {
+    _this->_impl_.machine_ = new ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine(*from._impl_.machine_);
+  }
+  if (from._internal_has_process()) {
+    _this->_impl_.process_ = new ::safe_browsing::ClientIncidentReport_EnvironmentData_Process(*from._impl_.process_);
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData)
+}
+
+inline void ClientIncidentReport_EnvironmentData::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.os_){nullptr}
+    , decltype(_impl_.machine_){nullptr}
+    , decltype(_impl_.process_){nullptr}
+  };
+}
+
+ClientIncidentReport_EnvironmentData::~ClientIncidentReport_EnvironmentData() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_EnvironmentData::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.os_;
+  if (this != internal_default_instance()) delete _impl_.machine_;
+  if (this != internal_default_instance()) delete _impl_.process_;
+}
+
+void ClientIncidentReport_EnvironmentData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_EnvironmentData::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.os_ != nullptr);
+      _impl_.os_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.machine_ != nullptr);
+      _impl_.machine_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.process_ != nullptr);
+      _impl_.process_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_EnvironmentData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .safe_browsing.ClientIncidentReport.EnvironmentData.OS os = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_os(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Machine machine = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_machine(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process process = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_process(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_EnvironmentData::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.OS os = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::os(this),
+        _Internal::os(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Machine machine = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::machine(this),
+        _Internal::machine(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process process = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::process(this),
+        _Internal::process(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.EnvironmentData)
+  return target;
+}
+
+size_t ClientIncidentReport_EnvironmentData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.EnvironmentData)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional .safe_browsing.ClientIncidentReport.EnvironmentData.OS os = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.os_);
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Machine machine = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.machine_);
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process process = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.process_);
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_EnvironmentData*>(
+      &from));
+}
+
+void ClientIncidentReport_EnvironmentData::MergeFrom(const ClientIncidentReport_EnvironmentData& from) {
+  ClientIncidentReport_EnvironmentData* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_os()->::safe_browsing::ClientIncidentReport_EnvironmentData_OS::MergeFrom(
+          from._internal_os());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_machine()->::safe_browsing::ClientIncidentReport_EnvironmentData_Machine::MergeFrom(
+          from._internal_machine());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_process()->::safe_browsing::ClientIncidentReport_EnvironmentData_Process::MergeFrom(
+          from._internal_process());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_EnvironmentData::CopyFrom(const ClientIncidentReport_EnvironmentData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.EnvironmentData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData::IsInitialized() const {
+  if (_internal_has_process()) {
+    if (!_impl_.process_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData::InternalSwap(ClientIncidentReport_EnvironmentData* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientIncidentReport_EnvironmentData, _impl_.process_)
+      + sizeof(ClientIncidentReport_EnvironmentData::_impl_.process_)
+      - PROTOBUF_FIELD_OFFSET(ClientIncidentReport_EnvironmentData, _impl_.os_)>(
+          reinterpret_cast<char*>(&_impl_.os_),
+          reinterpret_cast<char*>(&other->_impl_.os_));
+}
+
+std::string ClientIncidentReport_EnvironmentData::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_ExtensionData_ExtensionInfo::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_ExtensionData_ExtensionInfo>()._impl_._has_bits_);
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_description(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_state(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_update_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_has_signature_validation(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_signature_is_valid(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_installed_by_custodian(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+  static void set_has_installed_by_default(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_installed_by_oem(HasBits* has_bits) {
+    (*has_bits)[0] |= 4096u;
+  }
+  static void set_has_from_bookmark(HasBits* has_bits) {
+    (*has_bits)[0] |= 8192u;
+  }
+  static void set_has_from_webstore(HasBits* has_bits) {
+    (*has_bits)[0] |= 16384u;
+  }
+  static void set_has_converted_from_user_script(HasBits* has_bits) {
+    (*has_bits)[0] |= 32768u;
+  }
+  static void set_has_may_be_untrusted(HasBits* has_bits) {
+    (*has_bits)[0] |= 131072u;
+  }
+  static void set_has_install_time_msec(HasBits* has_bits) {
+    (*has_bits)[0] |= 65536u;
+  }
+  static void set_has_manifest_location_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 262144u;
+  }
+  static void set_has_manifest(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+};
+
+ClientIncidentReport_ExtensionData_ExtensionInfo::ClientIncidentReport_ExtensionData_ExtensionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+}
+ClientIncidentReport_ExtensionData_ExtensionInfo::ClientIncidentReport_ExtensionData_ExtensionInfo(const ClientIncidentReport_ExtensionData_ExtensionInfo& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_ExtensionData_ExtensionInfo* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.version_){}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.update_url_){}
+    , decltype(_impl_.manifest_){}
+    , decltype(_impl_.state_){}
+    , decltype(_impl_.type_){}
+    , decltype(_impl_.has_signature_validation_){}
+    , decltype(_impl_.signature_is_valid_){}
+    , decltype(_impl_.installed_by_custodian_){}
+    , decltype(_impl_.installed_by_default_){}
+    , decltype(_impl_.installed_by_oem_){}
+    , decltype(_impl_.from_bookmark_){}
+    , decltype(_impl_.from_webstore_){}
+    , decltype(_impl_.converted_from_user_script_){}
+    , decltype(_impl_.install_time_msec_){}
+    , decltype(_impl_.may_be_untrusted_){}
+    , decltype(_impl_.manifest_location_type_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_id()) {
+    _this->_impl_.id_.Set(from._internal_id(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_version()) {
+    _this->_impl_.version_.Set(from._internal_version(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_description()) {
+    _this->_impl_.description_.Set(from._internal_description(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.update_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.update_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_update_url()) {
+    _this->_impl_.update_url_.Set(from._internal_update_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.manifest_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.manifest_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_manifest()) {
+    _this->_impl_.manifest_.Set(from._internal_manifest(),
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.state_, &from._impl_.state_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.manifest_location_type_) -
+    reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.manifest_location_type_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+}
+
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.version_){}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.description_){}
+    , decltype(_impl_.update_url_){}
+    , decltype(_impl_.manifest_){}
+    , decltype(_impl_.state_){0}
+    , decltype(_impl_.type_){0}
+    , decltype(_impl_.has_signature_validation_){false}
+    , decltype(_impl_.signature_is_valid_){false}
+    , decltype(_impl_.installed_by_custodian_){false}
+    , decltype(_impl_.installed_by_default_){false}
+    , decltype(_impl_.installed_by_oem_){false}
+    , decltype(_impl_.from_bookmark_){false}
+    , decltype(_impl_.from_webstore_){false}
+    , decltype(_impl_.converted_from_user_script_){false}
+    , decltype(_impl_.install_time_msec_){int64_t{0}}
+    , decltype(_impl_.may_be_untrusted_){false}
+    , decltype(_impl_.manifest_location_type_){0}
+  };
+  _impl_.id_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.id_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.description_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.description_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.update_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.update_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.manifest_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.manifest_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_ExtensionData_ExtensionInfo::~ClientIncidentReport_ExtensionData_ExtensionInfo() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.id_.Destroy();
+  _impl_.version_.Destroy();
+  _impl_.name_.Destroy();
+  _impl_.description_.Destroy();
+  _impl_.update_url_.Destroy();
+  _impl_.manifest_.Destroy();
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.id_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.version_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.name_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.description_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.update_url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _impl_.manifest_.ClearNonDefaultToEmpty();
+    }
+  }
+  if (cached_has_bits & 0x000000c0u) {
+    ::memset(&_impl_.state_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.type_) -
+        reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.type_));
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    ::memset(&_impl_.has_signature_validation_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.converted_from_user_script_) -
+        reinterpret_cast<char*>(&_impl_.has_signature_validation_)) + sizeof(_impl_.converted_from_user_script_));
+  }
+  if (cached_has_bits & 0x00070000u) {
+    ::memset(&_impl_.install_time_msec_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.manifest_location_type_) -
+        reinterpret_cast<char*>(&_impl_.install_time_msec_)) + sizeof(_impl_.manifest_location_type_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_ExtensionData_ExtensionInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_id();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string version = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_version();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string name = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string description = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_description();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.ExtensionState state = 5 [default = STATE_UNKNOWN];
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_IsValid(val))) {
+            _internal_set_state(static_cast<::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 type = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          _Internal::set_has_type(&has_bits);
+          _impl_.type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string update_url = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_update_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool has_signature_validation = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_has_signature_validation(&has_bits);
+          _impl_.has_signature_validation_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool signature_is_valid = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          _Internal::set_has_signature_is_valid(&has_bits);
+          _impl_.signature_is_valid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool installed_by_custodian = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          _Internal::set_has_installed_by_custodian(&has_bits);
+          _impl_.installed_by_custodian_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool installed_by_default = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
+          _Internal::set_has_installed_by_default(&has_bits);
+          _impl_.installed_by_default_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool installed_by_oem = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          _Internal::set_has_installed_by_oem(&has_bits);
+          _impl_.installed_by_oem_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool from_bookmark = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 104)) {
+          _Internal::set_has_from_bookmark(&has_bits);
+          _impl_.from_bookmark_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool from_webstore = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
+          _Internal::set_has_from_webstore(&has_bits);
+          _impl_.from_webstore_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool converted_from_user_script = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 120)) {
+          _Internal::set_has_converted_from_user_script(&has_bits);
+          _impl_.converted_from_user_script_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool may_be_untrusted = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
+          _Internal::set_has_may_be_untrusted(&has_bits);
+          _impl_.may_be_untrusted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 install_time_msec = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 136)) {
+          _Internal::set_has_install_time_msec(&has_bits);
+          _impl_.install_time_msec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 manifest_location_type = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
+          _Internal::set_has_manifest_location_type(&has_bits);
+          _impl_.manifest_location_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string manifest = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
+          auto str = _internal_mutable_manifest();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_ExtensionData_ExtensionInfo::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string id = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_id(), target);
+  }
+
+  // optional string version = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_version(), target);
+  }
+
+  // optional string name = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_name(), target);
+  }
+
+  // optional string description = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_description(), target);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.ExtensionState state = 5 [default = STATE_UNKNOWN];
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      5, this->_internal_state(), target);
+  }
+
+  // optional int32 type = 6;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_type(), target);
+  }
+
+  // optional string update_url = 7;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_update_url(), target);
+  }
+
+  // optional bool has_signature_validation = 8;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_has_signature_validation(), target);
+  }
+
+  // optional bool signature_is_valid = 9;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(9, this->_internal_signature_is_valid(), target);
+  }
+
+  // optional bool installed_by_custodian = 10;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(10, this->_internal_installed_by_custodian(), target);
+  }
+
+  // optional bool installed_by_default = 11;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(11, this->_internal_installed_by_default(), target);
+  }
+
+  // optional bool installed_by_oem = 12;
+  if (cached_has_bits & 0x00001000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(12, this->_internal_installed_by_oem(), target);
+  }
+
+  // optional bool from_bookmark = 13;
+  if (cached_has_bits & 0x00002000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(13, this->_internal_from_bookmark(), target);
+  }
+
+  // optional bool from_webstore = 14;
+  if (cached_has_bits & 0x00004000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(14, this->_internal_from_webstore(), target);
+  }
+
+  // optional bool converted_from_user_script = 15;
+  if (cached_has_bits & 0x00008000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(15, this->_internal_converted_from_user_script(), target);
+  }
+
+  // optional bool may_be_untrusted = 16;
+  if (cached_has_bits & 0x00020000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(16, this->_internal_may_be_untrusted(), target);
+  }
+
+  // optional int64 install_time_msec = 17;
+  if (cached_has_bits & 0x00010000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(17, this->_internal_install_time_msec(), target);
+  }
+
+  // optional int32 manifest_location_type = 18;
+  if (cached_has_bits & 0x00040000u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(18, this->_internal_manifest_location_type(), target);
+  }
+
+  // optional string manifest = 19;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->WriteStringMaybeAliased(
+        19, this->_internal_manifest(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+  return target;
+}
+
+size_t ClientIncidentReport_ExtensionData_ExtensionInfo::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string id = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_id());
+    }
+
+    // optional string version = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_version());
+    }
+
+    // optional string name = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_name());
+    }
+
+    // optional string description = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_description());
+    }
+
+    // optional string update_url = 7;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_update_url());
+    }
+
+    // optional string manifest = 19;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_manifest());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.ExtensionState state = 5 [default = STATE_UNKNOWN];
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_state());
+    }
+
+    // optional int32 type = 6;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_type());
+    }
+
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    // optional bool has_signature_validation = 8;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool signature_is_valid = 9;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool installed_by_custodian = 10;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool installed_by_default = 11;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool installed_by_oem = 12;
+    if (cached_has_bits & 0x00001000u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool from_bookmark = 13;
+    if (cached_has_bits & 0x00002000u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool from_webstore = 14;
+    if (cached_has_bits & 0x00004000u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool converted_from_user_script = 15;
+    if (cached_has_bits & 0x00008000u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (cached_has_bits & 0x00070000u) {
+    // optional int64 install_time_msec = 17;
+    if (cached_has_bits & 0x00010000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::Int64Size(
+          this->_internal_install_time_msec());
+    }
+
+    // optional bool may_be_untrusted = 16;
+    if (cached_has_bits & 0x00020000u) {
+      total_size += 2 + 1;
+    }
+
+    // optional int32 manifest_location_type = 18;
+    if (cached_has_bits & 0x00040000u) {
+      total_size += 2 +
+        ::_pbi::WireFormatLite::Int32Size(
+          this->_internal_manifest_location_type());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_ExtensionData_ExtensionInfo*>(
+      &from));
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::MergeFrom(const ClientIncidentReport_ExtensionData_ExtensionInfo& from) {
+  ClientIncidentReport_ExtensionData_ExtensionInfo* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_id(from._internal_id());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_version(from._internal_version());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_description(from._internal_description());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_update_url(from._internal_update_url());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_set_manifest(from._internal_manifest());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.state_ = from._impl_.state_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.type_ = from._impl_.type_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x0000ff00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.has_signature_validation_ = from._impl_.has_signature_validation_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.signature_is_valid_ = from._impl_.signature_is_valid_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.installed_by_custodian_ = from._impl_.installed_by_custodian_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.installed_by_default_ = from._impl_.installed_by_default_;
+    }
+    if (cached_has_bits & 0x00001000u) {
+      _this->_impl_.installed_by_oem_ = from._impl_.installed_by_oem_;
+    }
+    if (cached_has_bits & 0x00002000u) {
+      _this->_impl_.from_bookmark_ = from._impl_.from_bookmark_;
+    }
+    if (cached_has_bits & 0x00004000u) {
+      _this->_impl_.from_webstore_ = from._impl_.from_webstore_;
+    }
+    if (cached_has_bits & 0x00008000u) {
+      _this->_impl_.converted_from_user_script_ = from._impl_.converted_from_user_script_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00070000u) {
+    if (cached_has_bits & 0x00010000u) {
+      _this->_impl_.install_time_msec_ = from._impl_.install_time_msec_;
+    }
+    if (cached_has_bits & 0x00020000u) {
+      _this->_impl_.may_be_untrusted_ = from._impl_.may_be_untrusted_;
+    }
+    if (cached_has_bits & 0x00040000u) {
+      _this->_impl_.manifest_location_type_ = from._impl_.manifest_location_type_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::CopyFrom(const ClientIncidentReport_ExtensionData_ExtensionInfo& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_ExtensionData_ExtensionInfo::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::InternalSwap(ClientIncidentReport_ExtensionData_ExtensionInfo* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.id_, lhs_arena,
+      &other->_impl_.id_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.version_, lhs_arena,
+      &other->_impl_.version_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.description_, lhs_arena,
+      &other->_impl_.description_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.update_url_, lhs_arena,
+      &other->_impl_.update_url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.manifest_, lhs_arena,
+      &other->_impl_.manifest_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientIncidentReport_ExtensionData_ExtensionInfo, _impl_.manifest_location_type_)
+      + sizeof(ClientIncidentReport_ExtensionData_ExtensionInfo::_impl_.manifest_location_type_)
+      - PROTOBUF_FIELD_OFFSET(ClientIncidentReport_ExtensionData_ExtensionInfo, _impl_.state_)>(
+          reinterpret_cast<char*>(&_impl_.state_),
+          reinterpret_cast<char*>(&other->_impl_.state_));
+}
+
+std::string ClientIncidentReport_ExtensionData_ExtensionInfo::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_ExtensionData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_ExtensionData>()._impl_._has_bits_);
+  static const ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo& last_installed_extension(const ClientIncidentReport_ExtensionData* msg);
+  static void set_has_last_installed_extension(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo&
+ClientIncidentReport_ExtensionData::_Internal::last_installed_extension(const ClientIncidentReport_ExtensionData* msg) {
+  return *msg->_impl_.last_installed_extension_;
+}
+ClientIncidentReport_ExtensionData::ClientIncidentReport_ExtensionData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.ExtensionData)
+}
+ClientIncidentReport_ExtensionData::ClientIncidentReport_ExtensionData(const ClientIncidentReport_ExtensionData& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_ExtensionData* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.last_installed_extension_){nullptr}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  if (from._internal_has_last_installed_extension()) {
+    _this->_impl_.last_installed_extension_ = new ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo(*from._impl_.last_installed_extension_);
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.ExtensionData)
+}
+
+inline void ClientIncidentReport_ExtensionData::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.last_installed_extension_){nullptr}
+  };
+}
+
+ClientIncidentReport_ExtensionData::~ClientIncidentReport_ExtensionData() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.ExtensionData)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_ExtensionData::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.last_installed_extension_;
+}
+
+void ClientIncidentReport_ExtensionData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_ExtensionData::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.ExtensionData)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.last_installed_extension_ != nullptr);
+    _impl_.last_installed_extension_->Clear();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_ExtensionData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo last_installed_extension = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_last_installed_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_ExtensionData::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.ExtensionData)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo last_installed_extension = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::last_installed_extension(this),
+        _Internal::last_installed_extension(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.ExtensionData)
+  return target;
+}
+
+size_t ClientIncidentReport_ExtensionData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.ExtensionData)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo last_installed_extension = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.last_installed_extension_);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_ExtensionData::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_ExtensionData*>(
+      &from));
+}
+
+void ClientIncidentReport_ExtensionData::MergeFrom(const ClientIncidentReport_ExtensionData& from) {
+  ClientIncidentReport_ExtensionData* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.ExtensionData)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_last_installed_extension()) {
+    _this->_internal_mutable_last_installed_extension()->::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo::MergeFrom(
+        from._internal_last_installed_extension());
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_ExtensionData::CopyFrom(const ClientIncidentReport_ExtensionData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.ExtensionData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_ExtensionData::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentReport_ExtensionData::InternalSwap(ClientIncidentReport_ExtensionData* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.last_installed_extension_, other->_impl_.last_installed_extension_);
+}
+
+std::string ClientIncidentReport_ExtensionData::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.ExtensionData";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport_NonBinaryDownloadDetails::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport_NonBinaryDownloadDetails>()._impl_._has_bits_);
+  static void set_has_file_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_url_spec_sha256(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_host(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_length(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+ClientIncidentReport_NonBinaryDownloadDetails::ClientIncidentReport_NonBinaryDownloadDetails(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+}
+ClientIncidentReport_NonBinaryDownloadDetails::ClientIncidentReport_NonBinaryDownloadDetails(const ClientIncidentReport_NonBinaryDownloadDetails& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport_NonBinaryDownloadDetails* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.file_type_){}
+    , decltype(_impl_.url_spec_sha256_){}
+    , decltype(_impl_.host_){}
+    , decltype(_impl_.length_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.file_type_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.file_type_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_file_type()) {
+    _this->_impl_.file_type_.Set(from._internal_file_type(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.url_spec_sha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_spec_sha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url_spec_sha256()) {
+    _this->_impl_.url_spec_sha256_.Set(from._internal_url_spec_sha256(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.host_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.host_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_host()) {
+    _this->_impl_.host_.Set(from._internal_host(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.length_ = from._impl_.length_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+}
+
+inline void ClientIncidentReport_NonBinaryDownloadDetails::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.file_type_){}
+    , decltype(_impl_.url_spec_sha256_){}
+    , decltype(_impl_.host_){}
+    , decltype(_impl_.length_){int64_t{0}}
+  };
+  _impl_.file_type_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.file_type_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.url_spec_sha256_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_spec_sha256_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.host_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.host_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentReport_NonBinaryDownloadDetails::~ClientIncidentReport_NonBinaryDownloadDetails() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport_NonBinaryDownloadDetails::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.file_type_.Destroy();
+  _impl_.url_spec_sha256_.Destroy();
+  _impl_.host_.Destroy();
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.file_type_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.url_spec_sha256_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.host_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.length_ = int64_t{0};
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport_NonBinaryDownloadDetails::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string file_type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_file_type();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes url_spec_sha256 = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_url_spec_sha256();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string host = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_host();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 length = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          _Internal::set_has_length(&has_bits);
+          _impl_.length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport_NonBinaryDownloadDetails::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string file_type = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_file_type(), target);
+  }
+
+  // optional bytes url_spec_sha256 = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_url_spec_sha256(), target);
+  }
+
+  // optional string host = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_host(), target);
+  }
+
+  // optional int64 length = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_length(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+  return target;
+}
+
+size_t ClientIncidentReport_NonBinaryDownloadDetails::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string file_type = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_file_type());
+    }
+
+    // optional bytes url_spec_sha256 = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_url_spec_sha256());
+    }
+
+    // optional string host = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_host());
+    }
+
+    // optional int64 length = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_length());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport_NonBinaryDownloadDetails*>(
+      &from));
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::MergeFrom(const ClientIncidentReport_NonBinaryDownloadDetails& from) {
+  ClientIncidentReport_NonBinaryDownloadDetails* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_file_type(from._internal_file_type());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_url_spec_sha256(from._internal_url_spec_sha256());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_host(from._internal_host());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.length_ = from._impl_.length_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::CopyFrom(const ClientIncidentReport_NonBinaryDownloadDetails& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_NonBinaryDownloadDetails::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::InternalSwap(ClientIncidentReport_NonBinaryDownloadDetails* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.file_type_, lhs_arena,
+      &other->_impl_.file_type_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_spec_sha256_, lhs_arena,
+      &other->_impl_.url_spec_sha256_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.host_, lhs_arena,
+      &other->_impl_.host_, rhs_arena
+  );
+  swap(_impl_.length_, other->_impl_.length_);
+}
+
+std::string ClientIncidentReport_NonBinaryDownloadDetails::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails";
+}
+
+
+// ===================================================================
+
+class ClientIncidentReport::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentReport>()._impl_._has_bits_);
+  static const ::safe_browsing::ClientIncidentReport_DownloadDetails& download(const ClientIncidentReport* msg);
+  static void set_has_download(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::safe_browsing::ClientIncidentReport_EnvironmentData& environment(const ClientIncidentReport* msg);
+  static void set_has_environment(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::safe_browsing::ChromeUserPopulation& population(const ClientIncidentReport* msg);
+  static void set_has_population(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::safe_browsing::ClientIncidentReport_ExtensionData& extension_data(const ClientIncidentReport* msg);
+  static void set_has_extension_data(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails& non_binary_download(const ClientIncidentReport* msg);
+  static void set_has_non_binary_download(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+};
+
+const ::safe_browsing::ClientIncidentReport_DownloadDetails&
+ClientIncidentReport::_Internal::download(const ClientIncidentReport* msg) {
+  return *msg->_impl_.download_;
+}
+const ::safe_browsing::ClientIncidentReport_EnvironmentData&
+ClientIncidentReport::_Internal::environment(const ClientIncidentReport* msg) {
+  return *msg->_impl_.environment_;
+}
+const ::safe_browsing::ChromeUserPopulation&
+ClientIncidentReport::_Internal::population(const ClientIncidentReport* msg) {
+  return *msg->_impl_.population_;
+}
+const ::safe_browsing::ClientIncidentReport_ExtensionData&
+ClientIncidentReport::_Internal::extension_data(const ClientIncidentReport* msg) {
+  return *msg->_impl_.extension_data_;
+}
+const ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails&
+ClientIncidentReport::_Internal::non_binary_download(const ClientIncidentReport* msg) {
+  return *msg->_impl_.non_binary_download_;
+}
+ClientIncidentReport::ClientIncidentReport(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentReport)
+}
+ClientIncidentReport::ClientIncidentReport(const ClientIncidentReport& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentReport* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.incident_){from._impl_.incident_}
+    , decltype(_impl_.download_){nullptr}
+    , decltype(_impl_.environment_){nullptr}
+    , decltype(_impl_.population_){nullptr}
+    , decltype(_impl_.extension_data_){nullptr}
+    , decltype(_impl_.non_binary_download_){nullptr}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  if (from._internal_has_download()) {
+    _this->_impl_.download_ = new ::safe_browsing::ClientIncidentReport_DownloadDetails(*from._impl_.download_);
+  }
+  if (from._internal_has_environment()) {
+    _this->_impl_.environment_ = new ::safe_browsing::ClientIncidentReport_EnvironmentData(*from._impl_.environment_);
+  }
+  if (from._internal_has_population()) {
+    _this->_impl_.population_ = new ::safe_browsing::ChromeUserPopulation(*from._impl_.population_);
+  }
+  if (from._internal_has_extension_data()) {
+    _this->_impl_.extension_data_ = new ::safe_browsing::ClientIncidentReport_ExtensionData(*from._impl_.extension_data_);
+  }
+  if (from._internal_has_non_binary_download()) {
+    _this->_impl_.non_binary_download_ = new ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails(*from._impl_.non_binary_download_);
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport)
+}
+
+inline void ClientIncidentReport::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.incident_){arena}
+    , decltype(_impl_.download_){nullptr}
+    , decltype(_impl_.environment_){nullptr}
+    , decltype(_impl_.population_){nullptr}
+    , decltype(_impl_.extension_data_){nullptr}
+    , decltype(_impl_.non_binary_download_){nullptr}
+  };
+}
+
+ClientIncidentReport::~ClientIncidentReport() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentReport::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.incident_.~RepeatedPtrField();
+  if (this != internal_default_instance()) delete _impl_.download_;
+  if (this != internal_default_instance()) delete _impl_.environment_;
+  if (this != internal_default_instance()) delete _impl_.population_;
+  if (this != internal_default_instance()) delete _impl_.extension_data_;
+  if (this != internal_default_instance()) delete _impl_.non_binary_download_;
+}
+
+void ClientIncidentReport::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentReport::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.incident_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      GOOGLE_DCHECK(_impl_.download_ != nullptr);
+      _impl_.download_->Clear();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.environment_ != nullptr);
+      _impl_.environment_->Clear();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.population_ != nullptr);
+      _impl_.population_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.extension_data_ != nullptr);
+      _impl_.extension_data_->Clear();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      GOOGLE_DCHECK(_impl_.non_binary_download_ != nullptr);
+      _impl_.non_binary_download_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentReport::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .safe_browsing.ClientIncidentReport.IncidentData incident = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_incident(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_download(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.EnvironmentData environment = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_environment(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ChromeUserPopulation population = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_population(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.ExtensionData extension_data = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr = ctx->ParseMessage(_internal_mutable_extension_data(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails non_binary_download = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_non_binary_download(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentReport::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientIncidentReport.IncidentData incident = 1;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_incident_size()); i < n; i++) {
+    const auto& repfield = this->_internal_incident(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::download(this),
+        _Internal::download(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData environment = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::environment(this),
+        _Internal::environment(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ChromeUserPopulation population = 7;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(7, _Internal::population(this),
+        _Internal::population(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.ExtensionData extension_data = 8;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(8, _Internal::extension_data(this),
+        _Internal::extension_data(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails non_binary_download = 9;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(9, _Internal::non_binary_download(this),
+        _Internal::non_binary_download(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentReport)
+  return target;
+}
+
+size_t ClientIncidentReport::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentReport)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientIncidentReport.IncidentData incident = 1;
+  total_size += 1UL * this->_internal_incident_size();
+  for (const auto& msg : this->_impl_.incident_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.download_);
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.EnvironmentData environment = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.environment_);
+    }
+
+    // optional .safe_browsing.ChromeUserPopulation population = 7;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.population_);
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.ExtensionData extension_data = 8;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.extension_data_);
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails non_binary_download = 9;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.non_binary_download_);
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentReport::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentReport*>(
+      &from));
+}
+
+void ClientIncidentReport::MergeFrom(const ClientIncidentReport& from) {
+  ClientIncidentReport* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.incident_.MergeFrom(from._impl_.incident_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_download()->::safe_browsing::ClientIncidentReport_DownloadDetails::MergeFrom(
+          from._internal_download());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_environment()->::safe_browsing::ClientIncidentReport_EnvironmentData::MergeFrom(
+          from._internal_environment());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(
+          from._internal_population());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_extension_data()->::safe_browsing::ClientIncidentReport_ExtensionData::MergeFrom(
+          from._internal_extension_data());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_mutable_non_binary_download()->::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails::MergeFrom(
+          from._internal_non_binary_download());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentReport::CopyFrom(const ClientIncidentReport& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentReport)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport::IsInitialized() const {
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.incident_))
+    return false;
+  if (_internal_has_download()) {
+    if (!_impl_.download_->IsInitialized()) return false;
+  }
+  if (_internal_has_environment()) {
+    if (!_impl_.environment_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport::InternalSwap(ClientIncidentReport* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.incident_.InternalSwap(&other->_impl_.incident_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientIncidentReport, _impl_.non_binary_download_)
+      + sizeof(ClientIncidentReport::_impl_.non_binary_download_)
+      - PROTOBUF_FIELD_OFFSET(ClientIncidentReport, _impl_.download_)>(
+          reinterpret_cast<char*>(&_impl_.download_),
+          reinterpret_cast<char*>(&other->_impl_.download_));
+}
+
+std::string ClientIncidentReport::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport";
+}
+
+
+// ===================================================================
+
+class ClientIncidentResponse_EnvironmentRequest::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentResponse_EnvironmentRequest>()._impl_._has_bits_);
+  static void set_has_dll_index(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+ClientIncidentResponse_EnvironmentRequest::ClientIncidentResponse_EnvironmentRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+}
+ClientIncidentResponse_EnvironmentRequest::ClientIncidentResponse_EnvironmentRequest(const ClientIncidentResponse_EnvironmentRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentResponse_EnvironmentRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.dll_index_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _this->_impl_.dll_index_ = from._impl_.dll_index_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+}
+
+inline void ClientIncidentResponse_EnvironmentRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.dll_index_){0}
+  };
+}
+
+ClientIncidentResponse_EnvironmentRequest::~ClientIncidentResponse_EnvironmentRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentResponse_EnvironmentRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ClientIncidentResponse_EnvironmentRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentResponse_EnvironmentRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.dll_index_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentResponse_EnvironmentRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional int32 dll_index = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_dll_index(&has_bits);
+          _impl_.dll_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentResponse_EnvironmentRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int32 dll_index = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_dll_index(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+  return target;
+}
+
+size_t ClientIncidentResponse_EnvironmentRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional int32 dll_index = 1;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_dll_index());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentResponse_EnvironmentRequest::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentResponse_EnvironmentRequest*>(
+      &from));
+}
+
+void ClientIncidentResponse_EnvironmentRequest::MergeFrom(const ClientIncidentResponse_EnvironmentRequest& from) {
+  ClientIncidentResponse_EnvironmentRequest* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_dll_index()) {
+    _this->_internal_set_dll_index(from._internal_dll_index());
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentResponse_EnvironmentRequest::CopyFrom(const ClientIncidentResponse_EnvironmentRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentResponse_EnvironmentRequest::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentResponse_EnvironmentRequest::InternalSwap(ClientIncidentResponse_EnvironmentRequest* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  swap(_impl_.dll_index_, other->_impl_.dll_index_);
+}
+
+std::string ClientIncidentResponse_EnvironmentRequest::GetTypeName() const {
+  return "safe_browsing.ClientIncidentResponse.EnvironmentRequest";
+}
+
+
+// ===================================================================
+
+class ClientIncidentResponse::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientIncidentResponse>()._impl_._has_bits_);
+  static void set_has_token(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_download_requested(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ClientIncidentResponse::ClientIncidentResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientIncidentResponse)
+}
+ClientIncidentResponse::ClientIncidentResponse(const ClientIncidentResponse& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientIncidentResponse* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.environment_requests_){from._impl_.environment_requests_}
+    , decltype(_impl_.token_){}
+    , decltype(_impl_.download_requested_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_token()) {
+    _this->_impl_.token_.Set(from._internal_token(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.download_requested_ = from._impl_.download_requested_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentResponse)
+}
+
+inline void ClientIncidentResponse::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.environment_requests_){arena}
+    , decltype(_impl_.token_){}
+    , decltype(_impl_.download_requested_){false}
+  };
+  _impl_.token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientIncidentResponse::~ClientIncidentResponse() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentResponse)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientIncidentResponse::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.environment_requests_.~RepeatedPtrField();
+  _impl_.token_.Destroy();
+}
+
+void ClientIncidentResponse::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientIncidentResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentResponse)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.environment_requests_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.token_.ClearNonDefaultToEmpty();
+  }
+  _impl_.download_requested_ = false;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientIncidentResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes token = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_token();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool download_requested = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_download_requested(&has_bits);
+          _impl_.download_requested_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientIncidentResponse.EnvironmentRequest environment_requests = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_environment_requests(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientIncidentResponse::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentResponse)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes token = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_token(), target);
+  }
+
+  // optional bool download_requested = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_download_requested(), target);
+  }
+
+  // repeated .safe_browsing.ClientIncidentResponse.EnvironmentRequest environment_requests = 3;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_environment_requests_size()); i < n; i++) {
+    const auto& repfield = this->_internal_environment_requests(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientIncidentResponse)
+  return target;
+}
+
+size_t ClientIncidentResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientIncidentResponse)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientIncidentResponse.EnvironmentRequest environment_requests = 3;
+  total_size += 1UL * this->_internal_environment_requests_size();
+  for (const auto& msg : this->_impl_.environment_requests_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional bytes token = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_token());
+    }
+
+    // optional bool download_requested = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientIncidentResponse::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientIncidentResponse*>(
+      &from));
+}
+
+void ClientIncidentResponse::MergeFrom(const ClientIncidentResponse& from) {
+  ClientIncidentResponse* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentResponse)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.environment_requests_.MergeFrom(from._impl_.environment_requests_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_token(from._internal_token());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.download_requested_ = from._impl_.download_requested_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientIncidentResponse::CopyFrom(const ClientIncidentResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientIncidentResponse)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentResponse::IsInitialized() const {
+  return true;
+}
+
+void ClientIncidentResponse::InternalSwap(ClientIncidentResponse* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.environment_requests_.InternalSwap(&other->_impl_.environment_requests_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.token_, lhs_arena,
+      &other->_impl_.token_, rhs_arena
+  );
+  swap(_impl_.download_requested_, other->_impl_.download_requested_);
+}
+
+std::string ClientIncidentResponse::GetTypeName() const {
+  return "safe_browsing.ClientIncidentResponse";
+}
+
+
+// ===================================================================
+
+class DownloadMetadata::_Internal {
+ public:
+  using HasBits = decltype(std::declval<DownloadMetadata>()._impl_._has_bits_);
+  static void set_has_download_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::safe_browsing::ClientIncidentReport_DownloadDetails& download(const DownloadMetadata* msg);
+  static void set_has_download(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::safe_browsing::ClientIncidentReport_DownloadDetails&
+DownloadMetadata::_Internal::download(const DownloadMetadata* msg) {
+  return *msg->_impl_.download_;
+}
+DownloadMetadata::DownloadMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.DownloadMetadata)
+}
+DownloadMetadata::DownloadMetadata(const DownloadMetadata& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  DownloadMetadata* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.download_){nullptr}
+    , decltype(_impl_.download_id_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  if (from._internal_has_download()) {
+    _this->_impl_.download_ = new ::safe_browsing::ClientIncidentReport_DownloadDetails(*from._impl_.download_);
+  }
+  _this->_impl_.download_id_ = from._impl_.download_id_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.DownloadMetadata)
+}
+
+inline void DownloadMetadata::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.download_){nullptr}
+    , decltype(_impl_.download_id_){0u}
+  };
+}
+
+DownloadMetadata::~DownloadMetadata() {
+  // @@protoc_insertion_point(destructor:safe_browsing.DownloadMetadata)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void DownloadMetadata::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.download_;
+}
+
+void DownloadMetadata::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void DownloadMetadata::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.DownloadMetadata)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    GOOGLE_DCHECK(_impl_.download_ != nullptr);
+    _impl_.download_->Clear();
+  }
+  _impl_.download_id_ = 0u;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* DownloadMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional uint32 download_id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_download_id(&has_bits);
+          _impl_.download_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_download(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DownloadMetadata::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.DownloadMetadata)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional uint32 download_id = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_download_id(), target);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::download(this),
+        _Internal::download(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.DownloadMetadata)
+  return target;
+}
+
+size_t DownloadMetadata::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.DownloadMetadata)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.download_);
+    }
+
+    // optional uint32 download_id = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_download_id());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void DownloadMetadata::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const DownloadMetadata*>(
+      &from));
+}
+
+void DownloadMetadata::MergeFrom(const DownloadMetadata& from) {
+  DownloadMetadata* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.DownloadMetadata)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_mutable_download()->::safe_browsing::ClientIncidentReport_DownloadDetails::MergeFrom(
+          from._internal_download());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.download_id_ = from._impl_.download_id_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void DownloadMetadata::CopyFrom(const DownloadMetadata& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.DownloadMetadata)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DownloadMetadata::IsInitialized() const {
+  if (_internal_has_download()) {
+    if (!_impl_.download_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void DownloadMetadata::InternalSwap(DownloadMetadata* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DownloadMetadata, _impl_.download_id_)
+      + sizeof(DownloadMetadata::_impl_.download_id_)
+      - PROTOBUF_FIELD_OFFSET(DownloadMetadata, _impl_.download_)>(
+          reinterpret_cast<char*>(&_impl_.download_),
+          reinterpret_cast<char*>(&other->_impl_.download_));
+}
+
+std::string DownloadMetadata::GetTypeName() const {
+  return "safe_browsing.DownloadMetadata";
+}
+
+
+// ===================================================================
+
+class ClientSafeBrowsingReportRequest_HTTPHeader::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_HTTPHeader>()._impl_._has_bits_);
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_value(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
+  }
+};
+
+ClientSafeBrowsingReportRequest_HTTPHeader::ClientSafeBrowsingReportRequest_HTTPHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+}
+ClientSafeBrowsingReportRequest_HTTPHeader::ClientSafeBrowsingReportRequest_HTTPHeader(const ClientSafeBrowsingReportRequest_HTTPHeader& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientSafeBrowsingReportRequest_HTTPHeader* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.value_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.value_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.value_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_value()) {
+    _this->_impl_.value_.Set(from._internal_value(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+}
+
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.value_){}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.value_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.value_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientSafeBrowsingReportRequest_HTTPHeader::~ClientSafeBrowsingReportRequest_HTTPHeader() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+  _impl_.value_.Destroy();
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.name_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.value_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientSafeBrowsingReportRequest_HTTPHeader::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required bytes name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_value();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientSafeBrowsingReportRequest_HTTPHeader::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required bytes name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // optional bytes value = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_value(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+  return target;
+}
+
+size_t ClientSafeBrowsingReportRequest_HTTPHeader::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+  size_t total_size = 0;
+
+  // required bytes name = 1;
+  if (_internal_has_name()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_name());
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // optional bytes value = 2;
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000002u) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_value());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientSafeBrowsingReportRequest_HTTPHeader*>(
+      &from));
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPHeader& from) {
+  ClientSafeBrowsingReportRequest_HTTPHeader* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_value(from._internal_value());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::CopyFrom(const ClientSafeBrowsingReportRequest_HTTPHeader& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPHeader::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::InternalSwap(ClientSafeBrowsingReportRequest_HTTPHeader* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.value_, lhs_arena,
+      &other->_impl_.value_, rhs_arena
+  );
+}
+
+std::string ClientSafeBrowsingReportRequest_HTTPHeader::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader";
+}
+
+
+// ===================================================================
+
+class ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine>()._impl_._has_bits_);
+  static void set_has_verb(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_uri(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+}
+ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.verb_){}
+    , decltype(_impl_.uri_){}
+    , decltype(_impl_.version_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.verb_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.verb_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_verb()) {
+    _this->_impl_.verb_.Set(from._internal_verb(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.uri_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.uri_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_uri()) {
+    _this->_impl_.uri_.Set(from._internal_uri(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_version()) {
+    _this->_impl_.version_.Set(from._internal_version(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+}
+
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.verb_){}
+    , decltype(_impl_.uri_){}
+    , decltype(_impl_.version_){}
+  };
+  _impl_.verb_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.verb_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.uri_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.uri_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::~ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.verb_.Destroy();
+  _impl_.uri_.Destroy();
+  _impl_.version_.Destroy();
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.verb_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.uri_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.version_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes verb = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_verb();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes uri = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_uri();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes version = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_version();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes verb = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_verb(), target);
+  }
+
+  // optional bytes uri = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_uri(), target);
+  }
+
+  // optional bytes version = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_version(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+  return target;
+}
+
+size_t ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional bytes verb = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_verb());
+    }
+
+    // optional bytes uri = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_uri());
+    }
+
+    // optional bytes version = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_version());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine*>(
+      &from));
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from) {
+  ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_verb(from._internal_verb());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_uri(from._internal_uri());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_version(from._internal_version());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::CopyFrom(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::IsInitialized() const {
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::InternalSwap(ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.verb_, lhs_arena,
+      &other->_impl_.verb_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.uri_, lhs_arena,
+      &other->_impl_.uri_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.version_, lhs_arena,
+      &other->_impl_.version_, rhs_arena
+  );
+}
+
+std::string ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine";
+}
+
+
+// ===================================================================
+
+class ClientSafeBrowsingReportRequest_HTTPRequest::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_HTTPRequest>()._impl_._has_bits_);
+  static const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& firstline(const ClientSafeBrowsingReportRequest_HTTPRequest* msg);
+  static void set_has_firstline(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_body(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_bodydigest(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_bodylength(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine&
+ClientSafeBrowsingReportRequest_HTTPRequest::_Internal::firstline(const ClientSafeBrowsingReportRequest_HTTPRequest* msg) {
+  return *msg->_impl_.firstline_;
+}
+ClientSafeBrowsingReportRequest_HTTPRequest::ClientSafeBrowsingReportRequest_HTTPRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+}
+ClientSafeBrowsingReportRequest_HTTPRequest::ClientSafeBrowsingReportRequest_HTTPRequest(const ClientSafeBrowsingReportRequest_HTTPRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientSafeBrowsingReportRequest_HTTPRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.headers_){from._impl_.headers_}
+    , decltype(_impl_.body_){}
+    , decltype(_impl_.bodydigest_){}
+    , decltype(_impl_.firstline_){nullptr}
+    , decltype(_impl_.bodylength_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.body_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.body_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_body()) {
+    _this->_impl_.body_.Set(from._internal_body(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.bodydigest_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.bodydigest_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_bodydigest()) {
+    _this->_impl_.bodydigest_.Set(from._internal_bodydigest(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_firstline()) {
+    _this->_impl_.firstline_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(*from._impl_.firstline_);
+  }
+  _this->_impl_.bodylength_ = from._impl_.bodylength_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+}
+
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.headers_){arena}
+    , decltype(_impl_.body_){}
+    , decltype(_impl_.bodydigest_){}
+    , decltype(_impl_.firstline_){nullptr}
+    , decltype(_impl_.bodylength_){0}
+  };
+  _impl_.body_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.body_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.bodydigest_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.bodydigest_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientSafeBrowsingReportRequest_HTTPRequest::~ClientSafeBrowsingReportRequest_HTTPRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.headers_.~RepeatedPtrField();
+  _impl_.body_.Destroy();
+  _impl_.bodydigest_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.firstline_;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.headers_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.body_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.bodydigest_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.firstline_ != nullptr);
+      _impl_.firstline_->Clear();
+    }
+  }
+  _impl_.bodylength_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientSafeBrowsingReportRequest_HTTPRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine firstline = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_firstline(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_headers(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes body = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_body();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes bodydigest = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_bodydigest();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 bodylength = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_bodylength(&has_bits);
+          _impl_.bodylength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientSafeBrowsingReportRequest_HTTPRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine firstline = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::firstline(this),
+        _Internal::firstline(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_headers_size()); i < n; i++) {
+    const auto& repfield = this->_internal_headers(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional bytes body = 3;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_body(), target);
+  }
+
+  // optional bytes bodydigest = 4;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_bodydigest(), target);
+  }
+
+  // optional int32 bodylength = 5;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_bodylength(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+  return target;
+}
+
+size_t ClientSafeBrowsingReportRequest_HTTPRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+  total_size += 1UL * this->_internal_headers_size();
+  for (const auto& msg : this->_impl_.headers_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional bytes body = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_body());
+    }
+
+    // optional bytes bodydigest = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_bodydigest());
+    }
+
+    // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine firstline = 1;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.firstline_);
+    }
+
+    // optional int32 bodylength = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_bodylength());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientSafeBrowsingReportRequest_HTTPRequest*>(
+      &from));
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPRequest& from) {
+  ClientSafeBrowsingReportRequest_HTTPRequest* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.headers_.MergeFrom(from._impl_.headers_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_body(from._internal_body());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_bodydigest(from._internal_bodydigest());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_firstline()->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::MergeFrom(
+          from._internal_firstline());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.bodylength_ = from._impl_.bodylength_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::CopyFrom(const ClientSafeBrowsingReportRequest_HTTPRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPRequest::IsInitialized() const {
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.headers_))
+    return false;
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::InternalSwap(ClientSafeBrowsingReportRequest_HTTPRequest* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.headers_.InternalSwap(&other->_impl_.headers_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.body_, lhs_arena,
+      &other->_impl_.body_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.bodydigest_, lhs_arena,
+      &other->_impl_.bodydigest_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientSafeBrowsingReportRequest_HTTPRequest, _impl_.bodylength_)
+      + sizeof(ClientSafeBrowsingReportRequest_HTTPRequest::_impl_.bodylength_)
+      - PROTOBUF_FIELD_OFFSET(ClientSafeBrowsingReportRequest_HTTPRequest, _impl_.firstline_)>(
+          reinterpret_cast<char*>(&_impl_.firstline_),
+          reinterpret_cast<char*>(&other->_impl_.firstline_));
+}
+
+std::string ClientSafeBrowsingReportRequest_HTTPRequest::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest";
+}
+
+
+// ===================================================================
+
+class ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine>()._impl_._has_bits_);
+  static void set_has_code(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_message(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+}
+ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.message_){}
+    , decltype(_impl_.version_){}
+    , decltype(_impl_.code_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.message_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.message_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_message()) {
+    _this->_impl_.message_.Set(from._internal_message(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_version()) {
+    _this->_impl_.version_.Set(from._internal_version(),
+      _this->GetArenaForAllocation());
+  }
+  _this->_impl_.code_ = from._impl_.code_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+}
+
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.message_){}
+    , decltype(_impl_.version_){}
+    , decltype(_impl_.code_){0}
+  };
+  _impl_.message_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.message_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::~ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.message_.Destroy();
+  _impl_.version_.Destroy();
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.message_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.version_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_.code_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional int32 code = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_code(&has_bits);
+          _impl_.code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes message = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_message();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes version = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_version();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int32 code = 1;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_code(), target);
+  }
+
+  // optional bytes message = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        2, this->_internal_message(), target);
+  }
+
+  // optional bytes version = 3;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_version(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+  return target;
+}
+
+size_t ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional bytes message = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_message());
+    }
+
+    // optional bytes version = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_version());
+    }
+
+    // optional int32 code = 1;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_code());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine*>(
+      &from));
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from) {
+  ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_message(from._internal_message());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_version(from._internal_version());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.code_ = from._impl_.code_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::CopyFrom(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::IsInitialized() const {
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::InternalSwap(ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.message_, lhs_arena,
+      &other->_impl_.message_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.version_, lhs_arena,
+      &other->_impl_.version_, rhs_arena
+  );
+  swap(_impl_.code_, other->_impl_.code_);
+}
+
+std::string ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine";
+}
+
+
+// ===================================================================
+
+class ClientSafeBrowsingReportRequest_HTTPResponse::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_HTTPResponse>()._impl_._has_bits_);
+  static const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& firstline(const ClientSafeBrowsingReportRequest_HTTPResponse* msg);
+  static void set_has_firstline(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_body(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_bodydigest(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_bodylength(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_remote_ip(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine&
+ClientSafeBrowsingReportRequest_HTTPResponse::_Internal::firstline(const ClientSafeBrowsingReportRequest_HTTPResponse* msg) {
+  return *msg->_impl_.firstline_;
+}
+ClientSafeBrowsingReportRequest_HTTPResponse::ClientSafeBrowsingReportRequest_HTTPResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+}
+ClientSafeBrowsingReportRequest_HTTPResponse::ClientSafeBrowsingReportRequest_HTTPResponse(const ClientSafeBrowsingReportRequest_HTTPResponse& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientSafeBrowsingReportRequest_HTTPResponse* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.headers_){from._impl_.headers_}
+    , decltype(_impl_.body_){}
+    , decltype(_impl_.bodydigest_){}
+    , decltype(_impl_.remote_ip_){}
+    , decltype(_impl_.firstline_){nullptr}
+    , decltype(_impl_.bodylength_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.body_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.body_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_body()) {
+    _this->_impl_.body_.Set(from._internal_body(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.bodydigest_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.bodydigest_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_bodydigest()) {
+    _this->_impl_.bodydigest_.Set(from._internal_bodydigest(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.remote_ip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.remote_ip_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_remote_ip()) {
+    _this->_impl_.remote_ip_.Set(from._internal_remote_ip(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_firstline()) {
+    _this->_impl_.firstline_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(*from._impl_.firstline_);
+  }
+  _this->_impl_.bodylength_ = from._impl_.bodylength_;
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+}
+
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.headers_){arena}
+    , decltype(_impl_.body_){}
+    , decltype(_impl_.bodydigest_){}
+    , decltype(_impl_.remote_ip_){}
+    , decltype(_impl_.firstline_){nullptr}
+    , decltype(_impl_.bodylength_){0}
+  };
+  _impl_.body_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.body_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.bodydigest_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.bodydigest_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.remote_ip_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.remote_ip_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientSafeBrowsingReportRequest_HTTPResponse::~ClientSafeBrowsingReportRequest_HTTPResponse() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.headers_.~RepeatedPtrField();
+  _impl_.body_.Destroy();
+  _impl_.bodydigest_.Destroy();
+  _impl_.remote_ip_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.firstline_;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.headers_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.body_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.bodydigest_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.remote_ip_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.firstline_ != nullptr);
+      _impl_.firstline_->Clear();
+    }
+  }
+  _impl_.bodylength_ = 0;
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientSafeBrowsingReportRequest_HTTPResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine firstline = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_firstline(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_headers(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes body = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_body();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes bodydigest = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_bodydigest();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 bodylength = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_bodylength(&has_bits);
+          _impl_.bodylength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes remote_ip = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          auto str = _internal_mutable_remote_ip();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientSafeBrowsingReportRequest_HTTPResponse::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine firstline = 1;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, _Internal::firstline(this),
+        _Internal::firstline(this).GetCachedSize(), target, stream);
+  }
+
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_headers_size()); i < n; i++) {
+    const auto& repfield = this->_internal_headers(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional bytes body = 3;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        3, this->_internal_body(), target);
+  }
+
+  // optional bytes bodydigest = 4;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteBytesMaybeAliased(
+        4, this->_internal_bodydigest(), target);
+  }
+
+  // optional int32 bodylength = 5;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_bodylength(), target);
+  }
+
+  // optional bytes remote_ip = 6;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteBytesMaybeAliased(
+        6, this->_internal_remote_ip(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+  return target;
+}
+
+size_t ClientSafeBrowsingReportRequest_HTTPResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+  total_size += 1UL * this->_internal_headers_size();
+  for (const auto& msg : this->_impl_.headers_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // optional bytes body = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_body());
+    }
+
+    // optional bytes bodydigest = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_bodydigest());
+    }
+
+    // optional bytes remote_ip = 6;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_remote_ip());
+    }
+
+    // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine firstline = 1;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.firstline_);
+    }
+
+    // optional int32 bodylength = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_bodylength());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientSafeBrowsingReportRequest_HTTPResponse*>(
+      &from));
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPResponse& from) {
+  ClientSafeBrowsingReportRequest_HTTPResponse* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.headers_.MergeFrom(from._impl_.headers_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_body(from._internal_body());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_bodydigest(from._internal_bodydigest());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_remote_ip(from._internal_remote_ip());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_firstline()->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::MergeFrom(
+          from._internal_firstline());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.bodylength_ = from._impl_.bodylength_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::CopyFrom(const ClientSafeBrowsingReportRequest_HTTPResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPResponse::IsInitialized() const {
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.headers_))
+    return false;
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::InternalSwap(ClientSafeBrowsingReportRequest_HTTPResponse* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.headers_.InternalSwap(&other->_impl_.headers_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.body_, lhs_arena,
+      &other->_impl_.body_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.bodydigest_, lhs_arena,
+      &other->_impl_.bodydigest_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.remote_ip_, lhs_arena,
+      &other->_impl_.remote_ip_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientSafeBrowsingReportRequest_HTTPResponse, _impl_.bodylength_)
+      + sizeof(ClientSafeBrowsingReportRequest_HTTPResponse::_impl_.bodylength_)
+      - PROTOBUF_FIELD_OFFSET(ClientSafeBrowsingReportRequest_HTTPResponse, _impl_.firstline_)>(
+          reinterpret_cast<char*>(&_impl_.firstline_),
+          reinterpret_cast<char*>(&other->_impl_.firstline_));
+}
+
+std::string ClientSafeBrowsingReportRequest_HTTPResponse::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse";
+}
+
+
+// ===================================================================
+
+class ClientSafeBrowsingReportRequest_Resource::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_Resource>()._impl_._has_bits_);
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest& request(const ClientSafeBrowsingReportRequest_Resource* msg);
+  static void set_has_request(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse& response(const ClientSafeBrowsingReportRequest_Resource* msg);
+  static void set_has_response(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_parent_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_tag_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static bool MissingRequiredFields(const HasBits& has_bits) {
+    return ((has_bits[0] & 0x00000010) ^ 0x00000010) != 0;
+  }
+};
+
+const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest&
+ClientSafeBrowsingReportRequest_Resource::_Internal::request(const ClientSafeBrowsingReportRequest_Resource* msg) {
+  return *msg->_impl_.request_;
+}
+const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse&
+ClientSafeBrowsingReportRequest_Resource::_Internal::response(const ClientSafeBrowsingReportRequest_Resource* msg) {
+  return *msg->_impl_.response_;
+}
+ClientSafeBrowsingReportRequest_Resource::ClientSafeBrowsingReportRequest_Resource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+}
+ClientSafeBrowsingReportRequest_Resource::ClientSafeBrowsingReportRequest_Resource(const ClientSafeBrowsingReportRequest_Resource& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientSafeBrowsingReportRequest_Resource* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.child_ids_){from._impl_.child_ids_}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.tag_name_){}
+    , decltype(_impl_.request_){nullptr}
+    , decltype(_impl_.response_){nullptr}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.parent_id_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.tag_name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.tag_name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_tag_name()) {
+    _this->_impl_.tag_name_.Set(from._internal_tag_name(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_request()) {
+    _this->_impl_.request_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest(*from._impl_.request_);
+  }
+  if (from._internal_has_response()) {
+    _this->_impl_.response_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse(*from._impl_.response_);
+  }
+  ::memcpy(&_impl_.id_, &from._impl_.id_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.parent_id_) -
+    reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.parent_id_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+}
+
+inline void ClientSafeBrowsingReportRequest_Resource::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.child_ids_){arena}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.tag_name_){}
+    , decltype(_impl_.request_){nullptr}
+    , decltype(_impl_.response_){nullptr}
+    , decltype(_impl_.id_){0}
+    , decltype(_impl_.parent_id_){0}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.tag_name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.tag_name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientSafeBrowsingReportRequest_Resource::~ClientSafeBrowsingReportRequest_Resource() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientSafeBrowsingReportRequest_Resource::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.child_ids_.~RepeatedField();
+  _impl_.url_.Destroy();
+  _impl_.tag_name_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.request_;
+  if (this != internal_default_instance()) delete _impl_.response_;
+}
+
+void ClientSafeBrowsingReportRequest_Resource::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientSafeBrowsingReportRequest_Resource::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.child_ids_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.tag_name_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.request_ != nullptr);
+      _impl_.request_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.response_ != nullptr);
+      _impl_.response_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x00000030u) {
+    ::memset(&_impl_.id_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.parent_id_) -
+        reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.parent_id_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientSafeBrowsingReportRequest_Resource::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // required int32 id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_id(&has_bits);
+          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string url = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest request = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_request(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse response = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_response(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 parent_id = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_parent_id(&has_bits);
+          _impl_.parent_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated int32 child_ids = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            _internal_add_child_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<48>(ptr));
+        } else if (static_cast<uint8_t>(tag) == 50) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_child_ids(), ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string tag_name = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_tag_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientSafeBrowsingReportRequest_Resource::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // required int32 id = 1;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_id(), target);
+  }
+
+  // optional string url = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_url(), target);
+  }
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest request = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::request(this),
+        _Internal::request(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse response = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::response(this),
+        _Internal::response(this).GetCachedSize(), target, stream);
+  }
+
+  // optional int32 parent_id = 5;
+  if (cached_has_bits & 0x00000020u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_parent_id(), target);
+  }
+
+  // repeated int32 child_ids = 6;
+  for (int i = 0, n = this->_internal_child_ids_size(); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_child_ids(i), target);
+  }
+
+  // optional string tag_name = 7;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_tag_name(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+  return target;
+}
+
+size_t ClientSafeBrowsingReportRequest_Resource::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+  size_t total_size = 0;
+
+  // required int32 id = 1;
+  if (_internal_has_id()) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_id());
+  }
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated int32 child_ids = 6;
+  {
+    size_t data_size = ::_pbi::WireFormatLite::
+      Int32Size(this->_impl_.child_ids_);
+    total_size += 1 *
+                  ::_pbi::FromIntSize(this->_internal_child_ids_size());
+    total_size += data_size;
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string url = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional string tag_name = 7;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_tag_name());
+    }
+
+    // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest request = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.request_);
+    }
+
+    // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse response = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.response_);
+    }
+
+  }
+  // optional int32 parent_id = 5;
+  if (cached_has_bits & 0x00000020u) {
+    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_parent_id());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest_Resource::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientSafeBrowsingReportRequest_Resource*>(
+      &from));
+}
+
+void ClientSafeBrowsingReportRequest_Resource::MergeFrom(const ClientSafeBrowsingReportRequest_Resource& from) {
+  ClientSafeBrowsingReportRequest_Resource* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.child_ids_.MergeFrom(from._impl_.child_ids_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_tag_name(from._internal_tag_name());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_request()->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest::MergeFrom(
+          from._internal_request());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_response()->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse::MergeFrom(
+          from._internal_response());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_impl_.id_ = from._impl_.id_;
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_impl_.parent_id_ = from._impl_.parent_id_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientSafeBrowsingReportRequest_Resource::CopyFrom(const ClientSafeBrowsingReportRequest_Resource& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest_Resource::IsInitialized() const {
+  if (_Internal::MissingRequiredFields(_impl_._has_bits_)) return false;
+  if (_internal_has_request()) {
+    if (!_impl_.request_->IsInitialized()) return false;
+  }
+  if (_internal_has_response()) {
+    if (!_impl_.response_->IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest_Resource::InternalSwap(ClientSafeBrowsingReportRequest_Resource* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.child_ids_.InternalSwap(&other->_impl_.child_ids_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.tag_name_, lhs_arena,
+      &other->_impl_.tag_name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientSafeBrowsingReportRequest_Resource, _impl_.parent_id_)
+      + sizeof(ClientSafeBrowsingReportRequest_Resource::_impl_.parent_id_)
+      - PROTOBUF_FIELD_OFFSET(ClientSafeBrowsingReportRequest_Resource, _impl_.request_)>(
+          reinterpret_cast<char*>(&_impl_.request_),
+          reinterpret_cast<char*>(&other->_impl_.request_));
+}
+
+std::string ClientSafeBrowsingReportRequest_Resource::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest.Resource";
+}
+
+
+// ===================================================================
+
+class ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties>()._impl_._has_bits_);
+  static void set_has_client_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_google_play_services_version(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_is_instant_apps(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_url_api_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties)
+}
+ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.client_version_){}
+    , decltype(_impl_.google_play_services_version_){}
+    , decltype(_impl_.is_instant_apps_){}
+    , decltype(_impl_.url_api_type_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.client_version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.client_version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_client_version()) {
+    _this->_impl_.client_version_.Set(from._internal_client_version(),
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.google_play_services_version_, &from._impl_.google_play_services_version_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.url_api_type_) -
+    reinterpret_cast<char*>(&_impl_.google_play_services_version_)) + sizeof(_impl_.url_api_type_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties)
+}
+
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.client_version_){}
+    , decltype(_impl_.google_play_services_version_){int64_t{0}}
+    , decltype(_impl_.is_instant_apps_){false}
+    , decltype(_impl_.url_api_type_){0}
+  };
+  _impl_.client_version_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.client_version_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::~ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.client_version_.Destroy();
+}
+
+void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.client_version_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x0000000eu) {
+    ::memset(&_impl_.google_play_services_version_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.url_api_type_) -
+        reinterpret_cast<char*>(&_impl_.google_play_services_version_)) + sizeof(_impl_.url_api_type_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string client_version = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_client_version();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int64 google_play_services_version = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_google_play_services_version(&has_bits);
+          _impl_.google_play_services_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool is_instant_apps = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _Internal::set_has_is_instant_apps(&has_bits);
+          _impl_.is_instant_apps_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingUrlApiType url_api_type = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_IsValid(val))) {
+            _internal_set_url_api_type(static_cast<::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string client_version = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_client_version(), target);
+  }
+
+  // optional int64 google_play_services_version = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_google_play_services_version(), target);
+  }
+
+  // optional bool is_instant_apps = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_is_instant_apps(), target);
+  }
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingUrlApiType url_api_type = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_url_api_type(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties)
+  return target;
+}
+
+size_t ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional string client_version = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_client_version());
+    }
+
+    // optional int64 google_play_services_version = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_google_play_services_version());
+    }
+
+    // optional bool is_instant_apps = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 + 1;
+    }
+
+    // optional .safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingUrlApiType url_api_type = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_url_api_type());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties*>(
+      &from));
+}
+
+void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::MergeFrom(const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& from) {
+  ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_client_version(from._internal_client_version());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.google_play_services_version_ = from._impl_.google_play_services_version_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.is_instant_apps_ = from._impl_.is_instant_apps_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_impl_.url_api_type_ = from._impl_.url_api_type_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::CopyFrom(const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::IsInitialized() const {
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::InternalSwap(ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.client_version_, lhs_arena,
+      &other->_impl_.client_version_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties, _impl_.url_api_type_)
+      + sizeof(ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_impl_.url_api_type_)
+      - PROTOBUF_FIELD_OFFSET(ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties, _impl_.google_play_services_version_)>(
+          reinterpret_cast<char*>(&_impl_.google_play_services_version_),
+          reinterpret_cast<char*>(&other->_impl_.google_play_services_version_));
+}
+
+std::string ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties";
+}
+
+
+// ===================================================================
+
+class ClientSafeBrowsingReportRequest::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest>()._impl_._has_bits_);
+  static void set_has_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 64u;
+  }
+  static void set_has_download_verdict(HasBits* has_bits) {
+    (*has_bits)[0] |= 2048u;
+  }
+  static void set_has_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_page_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_referrer_url(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_complete(HasBits* has_bits) {
+    (*has_bits)[0] |= 128u;
+  }
+  static void set_has_client_country(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_did_proceed(HasBits* has_bits) {
+    (*has_bits)[0] |= 256u;
+  }
+  static void set_has_repeat_visit(HasBits* has_bits) {
+    (*has_bits)[0] |= 512u;
+  }
+  static void set_has_token(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+  static const ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& client_properties(const ClientSafeBrowsingReportRequest* msg);
+  static void set_has_client_properties(HasBits* has_bits) {
+    (*has_bits)[0] |= 32u;
+  }
+  static void set_has_show_download_in_folder(HasBits* has_bits) {
+    (*has_bits)[0] |= 1024u;
+  }
+};
+
+const ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties&
+ClientSafeBrowsingReportRequest::_Internal::client_properties(const ClientSafeBrowsingReportRequest* msg) {
+  return *msg->_impl_.client_properties_;
+}
+ClientSafeBrowsingReportRequest::ClientSafeBrowsingReportRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ClientSafeBrowsingReportRequest)
+}
+ClientSafeBrowsingReportRequest::ClientSafeBrowsingReportRequest(const ClientSafeBrowsingReportRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ClientSafeBrowsingReportRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.resources_){from._impl_.resources_}
+    , decltype(_impl_.client_asn_){from._impl_.client_asn_}
+    , decltype(_impl_.dom_){from._impl_.dom_}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.page_url_){}
+    , decltype(_impl_.referrer_url_){}
+    , decltype(_impl_.client_country_){}
+    , decltype(_impl_.token_){}
+    , decltype(_impl_.client_properties_){nullptr}
+    , decltype(_impl_.type_){}
+    , decltype(_impl_.complete_){}
+    , decltype(_impl_.did_proceed_){}
+    , decltype(_impl_.repeat_visit_){}
+    , decltype(_impl_.show_download_in_folder_){}
+    , decltype(_impl_.download_verdict_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_url()) {
+    _this->_impl_.url_.Set(from._internal_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.page_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.page_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_page_url()) {
+    _this->_impl_.page_url_.Set(from._internal_page_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.referrer_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.referrer_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_referrer_url()) {
+    _this->_impl_.referrer_url_.Set(from._internal_referrer_url(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.client_country_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.client_country_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_client_country()) {
+    _this->_impl_.client_country_.Set(from._internal_client_country(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_token()) {
+    _this->_impl_.token_.Set(from._internal_token(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_client_properties()) {
+    _this->_impl_.client_properties_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(*from._impl_.client_properties_);
+  }
+  ::memcpy(&_impl_.type_, &from._impl_.type_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.download_verdict_) -
+    reinterpret_cast<char*>(&_impl_.type_)) + sizeof(_impl_.download_verdict_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest)
+}
+
+inline void ClientSafeBrowsingReportRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.resources_){arena}
+    , decltype(_impl_.client_asn_){arena}
+    , decltype(_impl_.dom_){arena}
+    , decltype(_impl_.url_){}
+    , decltype(_impl_.page_url_){}
+    , decltype(_impl_.referrer_url_){}
+    , decltype(_impl_.client_country_){}
+    , decltype(_impl_.token_){}
+    , decltype(_impl_.client_properties_){nullptr}
+    , decltype(_impl_.type_){0}
+    , decltype(_impl_.complete_){false}
+    , decltype(_impl_.did_proceed_){false}
+    , decltype(_impl_.repeat_visit_){false}
+    , decltype(_impl_.show_download_in_folder_){false}
+    , decltype(_impl_.download_verdict_){0}
+  };
+  _impl_.url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.page_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.page_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.referrer_url_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.referrer_url_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.client_country_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.client_country_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.token_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.token_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ClientSafeBrowsingReportRequest::~ClientSafeBrowsingReportRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ClientSafeBrowsingReportRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.resources_.~RepeatedPtrField();
+  _impl_.client_asn_.~RepeatedPtrField();
+  _impl_.dom_.~RepeatedPtrField();
+  _impl_.url_.Destroy();
+  _impl_.page_url_.Destroy();
+  _impl_.referrer_url_.Destroy();
+  _impl_.client_country_.Destroy();
+  _impl_.token_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.client_properties_;
+}
+
+void ClientSafeBrowsingReportRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ClientSafeBrowsingReportRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.resources_.Clear();
+  _impl_.client_asn_.Clear();
+  _impl_.dom_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000003fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.page_url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _impl_.referrer_url_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _impl_.client_country_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _impl_.token_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000020u) {
+      GOOGLE_DCHECK(_impl_.client_properties_ != nullptr);
+      _impl_.client_properties_->Clear();
+    }
+  }
+  if (cached_has_bits & 0x000000c0u) {
+    ::memset(&_impl_.type_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.complete_) -
+        reinterpret_cast<char*>(&_impl_.type_)) + sizeof(_impl_.complete_));
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    ::memset(&_impl_.did_proceed_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.download_verdict_) -
+        reinterpret_cast<char*>(&_impl_.did_proceed_)) + sizeof(_impl_.download_verdict_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ClientSafeBrowsingReportRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string url = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string page_url = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_page_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string referrer_url = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_referrer_url();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.ClientSafeBrowsingReportRequest.Resource resources = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_resources(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool complete = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_complete(&has_bits);
+          _impl_.complete_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string client_asn = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_client_asn();
+            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string client_country = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          auto str = _internal_mutable_client_country();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool did_proceed = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          _Internal::set_has_did_proceed(&has_bits);
+          _impl_.did_proceed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool repeat_visit = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
+          _Internal::set_has_repeat_visit(&has_bits);
+          _impl_.repeat_visit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientSafeBrowsingReportRequest.ReportType type = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientSafeBrowsingReportRequest_ReportType_IsValid(val))) {
+            _internal_set_type(static_cast<::safe_browsing::ClientSafeBrowsingReportRequest_ReportType>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientDownloadResponse.Verdict download_verdict = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          if (PROTOBUF_PREDICT_TRUE(::safe_browsing::ClientDownloadResponse_Verdict_IsValid(val))) {
+            _internal_set_download_verdict(static_cast<::safe_browsing::ClientDownloadResponse_Verdict>(val));
+          } else {
+            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields());
+          }
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bytes token = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
+          auto str = _internal_mutable_token();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.HTMLElement dom = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          ptr -= 2;
+          do {
+            ptr += 2;
+            ptr = ctx->ParseMessage(_internal_add_dom(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<130>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties client_properties = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_client_properties(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional bool show_download_in_folder = 18;
+      case 18:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
+          _Internal::set_has_show_download_in_folder(&has_bits);
+          _impl_.show_download_in_folder_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ClientSafeBrowsingReportRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string url = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_url(), target);
+  }
+
+  // optional string page_url = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_page_url(), target);
+  }
+
+  // optional string referrer_url = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_referrer_url(), target);
+  }
+
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.Resource resources = 4;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_resources_size()); i < n; i++) {
+    const auto& repfield = this->_internal_resources(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional bool complete = 5;
+  if (cached_has_bits & 0x00000080u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_complete(), target);
+  }
+
+  // repeated string client_asn = 6;
+  for (int i = 0, n = this->_internal_client_asn_size(); i < n; i++) {
+    const auto& s = this->_internal_client_asn(i);
+    target = stream->WriteString(6, s, target);
+  }
+
+  // optional string client_country = 7;
+  if (cached_has_bits & 0x00000008u) {
+    target = stream->WriteStringMaybeAliased(
+        7, this->_internal_client_country(), target);
+  }
+
+  // optional bool did_proceed = 8;
+  if (cached_has_bits & 0x00000100u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_did_proceed(), target);
+  }
+
+  // optional bool repeat_visit = 9;
+  if (cached_has_bits & 0x00000200u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(9, this->_internal_repeat_visit(), target);
+  }
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.ReportType type = 10;
+  if (cached_has_bits & 0x00000040u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      10, this->_internal_type(), target);
+  }
+
+  // optional .safe_browsing.ClientDownloadResponse.Verdict download_verdict = 11;
+  if (cached_has_bits & 0x00000800u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+      11, this->_internal_download_verdict(), target);
+  }
+
+  // optional bytes token = 15;
+  if (cached_has_bits & 0x00000010u) {
+    target = stream->WriteBytesMaybeAliased(
+        15, this->_internal_token(), target);
+  }
+
+  // repeated .safe_browsing.HTMLElement dom = 16;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_dom_size()); i < n; i++) {
+    const auto& repfield = this->_internal_dom(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(16, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties client_properties = 17;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(17, _Internal::client_properties(this),
+        _Internal::client_properties(this).GetCachedSize(), target, stream);
+  }
+
+  // optional bool show_download_in_folder = 18;
+  if (cached_has_bits & 0x00000400u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteBoolToArray(18, this->_internal_show_download_in_folder(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ClientSafeBrowsingReportRequest)
+  return target;
+}
+
+size_t ClientSafeBrowsingReportRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ClientSafeBrowsingReportRequest)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.Resource resources = 4;
+  total_size += 1UL * this->_internal_resources_size();
+  for (const auto& msg : this->_impl_.resources_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated string client_asn = 6;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.client_asn_.size());
+  for (int i = 0, n = _impl_.client_asn_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      _impl_.client_asn_.Get(i));
+  }
+
+  // repeated .safe_browsing.HTMLElement dom = 16;
+  total_size += 2UL * this->_internal_dom_size();
+  for (const auto& msg : this->_impl_.dom_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    // optional string url = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_url());
+    }
+
+    // optional string page_url = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_page_url());
+    }
+
+    // optional string referrer_url = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_referrer_url());
+    }
+
+    // optional string client_country = 7;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_client_country());
+    }
+
+    // optional bytes token = 15;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_token());
+    }
+
+    // optional .safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties client_properties = 17;
+    if (cached_has_bits & 0x00000020u) {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.client_properties_);
+    }
+
+    // optional .safe_browsing.ClientSafeBrowsingReportRequest.ReportType type = 10;
+    if (cached_has_bits & 0x00000040u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
+    }
+
+    // optional bool complete = 5;
+    if (cached_has_bits & 0x00000080u) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    // optional bool did_proceed = 8;
+    if (cached_has_bits & 0x00000100u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool repeat_visit = 9;
+    if (cached_has_bits & 0x00000200u) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool show_download_in_folder = 18;
+    if (cached_has_bits & 0x00000400u) {
+      total_size += 2 + 1;
+    }
+
+    // optional .safe_browsing.ClientDownloadResponse.Verdict download_verdict = 11;
+    if (cached_has_bits & 0x00000800u) {
+      total_size += 1 +
+        ::_pbi::WireFormatLite::EnumSize(this->_internal_download_verdict());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ClientSafeBrowsingReportRequest*>(
+      &from));
+}
+
+void ClientSafeBrowsingReportRequest::MergeFrom(const ClientSafeBrowsingReportRequest& from) {
+  ClientSafeBrowsingReportRequest* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.resources_.MergeFrom(from._impl_.resources_);
+  _this->_impl_.client_asn_.MergeFrom(from._impl_.client_asn_);
+  _this->_impl_.dom_.MergeFrom(from._impl_.dom_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x000000ffu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_url(from._internal_url());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_page_url(from._internal_page_url());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_set_referrer_url(from._internal_referrer_url());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_set_client_country(from._internal_client_country());
+    }
+    if (cached_has_bits & 0x00000010u) {
+      _this->_internal_set_token(from._internal_token());
+    }
+    if (cached_has_bits & 0x00000020u) {
+      _this->_internal_mutable_client_properties()->::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::MergeFrom(
+          from._internal_client_properties());
+    }
+    if (cached_has_bits & 0x00000040u) {
+      _this->_impl_.type_ = from._impl_.type_;
+    }
+    if (cached_has_bits & 0x00000080u) {
+      _this->_impl_.complete_ = from._impl_.complete_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  if (cached_has_bits & 0x00000f00u) {
+    if (cached_has_bits & 0x00000100u) {
+      _this->_impl_.did_proceed_ = from._impl_.did_proceed_;
+    }
+    if (cached_has_bits & 0x00000200u) {
+      _this->_impl_.repeat_visit_ = from._impl_.repeat_visit_;
+    }
+    if (cached_has_bits & 0x00000400u) {
+      _this->_impl_.show_download_in_folder_ = from._impl_.show_download_in_folder_;
+    }
+    if (cached_has_bits & 0x00000800u) {
+      _this->_impl_.download_verdict_ = from._impl_.download_verdict_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ClientSafeBrowsingReportRequest::CopyFrom(const ClientSafeBrowsingReportRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ClientSafeBrowsingReportRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest::IsInitialized() const {
+  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(_impl_.resources_))
+    return false;
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest::InternalSwap(ClientSafeBrowsingReportRequest* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.resources_.InternalSwap(&other->_impl_.resources_);
+  _impl_.client_asn_.InternalSwap(&other->_impl_.client_asn_);
+  _impl_.dom_.InternalSwap(&other->_impl_.dom_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.url_, lhs_arena,
+      &other->_impl_.url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.page_url_, lhs_arena,
+      &other->_impl_.page_url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.referrer_url_, lhs_arena,
+      &other->_impl_.referrer_url_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.client_country_, lhs_arena,
+      &other->_impl_.client_country_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.token_, lhs_arena,
+      &other->_impl_.token_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ClientSafeBrowsingReportRequest, _impl_.download_verdict_)
+      + sizeof(ClientSafeBrowsingReportRequest::_impl_.download_verdict_)
+      - PROTOBUF_FIELD_OFFSET(ClientSafeBrowsingReportRequest, _impl_.client_properties_)>(
+          reinterpret_cast<char*>(&_impl_.client_properties_),
+          reinterpret_cast<char*>(&other->_impl_.client_properties_));
+}
+
+std::string ClientSafeBrowsingReportRequest::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest";
+}
+
+
+// ===================================================================
+
+class HTMLElement_Attribute::_Internal {
+ public:
+  using HasBits = decltype(std::declval<HTMLElement_Attribute>()._impl_._has_bits_);
+  static void set_has_name(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_value(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+HTMLElement_Attribute::HTMLElement_Attribute(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.HTMLElement.Attribute)
+}
+HTMLElement_Attribute::HTMLElement_Attribute(const HTMLElement_Attribute& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  HTMLElement_Attribute* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.value_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_name()) {
+    _this->_impl_.name_.Set(from._internal_name(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.value_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.value_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_value()) {
+    _this->_impl_.value_.Set(from._internal_value(),
+      _this->GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.HTMLElement.Attribute)
+}
+
+inline void HTMLElement_Attribute::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.name_){}
+    , decltype(_impl_.value_){}
+  };
+  _impl_.name_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.name_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.value_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.value_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+HTMLElement_Attribute::~HTMLElement_Attribute() {
+  // @@protoc_insertion_point(destructor:safe_browsing.HTMLElement.Attribute)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void HTMLElement_Attribute::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.name_.Destroy();
+  _impl_.value_.Destroy();
+}
+
+void HTMLElement_Attribute::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void HTMLElement_Attribute::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.HTMLElement.Attribute)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.name_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.value_.ClearNonDefaultToEmpty();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* HTMLElement_Attribute::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_value();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* HTMLElement_Attribute::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.HTMLElement.Attribute)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string name = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // optional string value = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_value(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.HTMLElement.Attribute)
+  return target;
+}
+
+size_t HTMLElement_Attribute::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.HTMLElement.Attribute)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string name = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_name());
+    }
+
+    // optional string value = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_value());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void HTMLElement_Attribute::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const HTMLElement_Attribute*>(
+      &from));
+}
+
+void HTMLElement_Attribute::MergeFrom(const HTMLElement_Attribute& from) {
+  HTMLElement_Attribute* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.HTMLElement.Attribute)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_name(from._internal_name());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_value(from._internal_value());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void HTMLElement_Attribute::CopyFrom(const HTMLElement_Attribute& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.HTMLElement.Attribute)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool HTMLElement_Attribute::IsInitialized() const {
+  return true;
+}
+
+void HTMLElement_Attribute::InternalSwap(HTMLElement_Attribute* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.name_, lhs_arena,
+      &other->_impl_.name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.value_, lhs_arena,
+      &other->_impl_.value_, rhs_arena
+  );
+}
+
+std::string HTMLElement_Attribute::GetTypeName() const {
+  return "safe_browsing.HTMLElement.Attribute";
+}
+
+
+// ===================================================================
+
+class HTMLElement::_Internal {
+ public:
+  using HasBits = decltype(std::declval<HTMLElement>()._impl_._has_bits_);
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_tag(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_resource_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+};
+
+HTMLElement::HTMLElement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.HTMLElement)
+}
+HTMLElement::HTMLElement(const HTMLElement& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  HTMLElement* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.child_ids_){from._impl_.child_ids_}
+    , decltype(_impl_.attribute_){from._impl_.attribute_}
+    , decltype(_impl_.tag_){}
+    , decltype(_impl_.id_){}
+    , decltype(_impl_.resource_id_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.tag_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.tag_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_tag()) {
+    _this->_impl_.tag_.Set(from._internal_tag(),
+      _this->GetArenaForAllocation());
+  }
+  ::memcpy(&_impl_.id_, &from._impl_.id_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.resource_id_) -
+    reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.resource_id_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.HTMLElement)
+}
+
+inline void HTMLElement::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.child_ids_){arena}
+    , decltype(_impl_.attribute_){arena}
+    , decltype(_impl_.tag_){}
+    , decltype(_impl_.id_){0}
+    , decltype(_impl_.resource_id_){0}
+  };
+  _impl_.tag_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.tag_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+HTMLElement::~HTMLElement() {
+  // @@protoc_insertion_point(destructor:safe_browsing.HTMLElement)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void HTMLElement::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.child_ids_.~RepeatedField();
+  _impl_.attribute_.~RepeatedPtrField();
+  _impl_.tag_.Destroy();
+}
+
+void HTMLElement::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void HTMLElement::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.HTMLElement)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  _impl_.child_ids_.Clear();
+  _impl_.attribute_.Clear();
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    _impl_.tag_.ClearNonDefaultToEmpty();
+  }
+  if (cached_has_bits & 0x00000006u) {
+    ::memset(&_impl_.id_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.resource_id_) -
+        reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.resource_id_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* HTMLElement::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional int32 id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_id(&has_bits);
+          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string tag = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_tag();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated int32 child_ids = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            _internal_add_child_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr));
+        } else if (static_cast<uint8_t>(tag) == 26) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_child_ids(), ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 resource_id = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _Internal::set_has_resource_id(&has_bits);
+          _impl_.resource_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .safe_browsing.HTMLElement.Attribute attribute = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_attribute(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* HTMLElement::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.HTMLElement)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int32 id = 1;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_id(), target);
+  }
+
+  // optional string tag = 2;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_tag(), target);
+  }
+
+  // repeated int32 child_ids = 3;
+  for (int i = 0, n = this->_internal_child_ids_size(); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_child_ids(i), target);
+  }
+
+  // optional int32 resource_id = 5;
+  if (cached_has_bits & 0x00000004u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_resource_id(), target);
+  }
+
+  // repeated .safe_browsing.HTMLElement.Attribute attribute = 6;
+  for (unsigned i = 0,
+      n = static_cast<unsigned>(this->_internal_attribute_size()); i < n; i++) {
+    const auto& repfield = this->_internal_attribute(i);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+        InternalWriteMessage(6, repfield, repfield.GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.HTMLElement)
+  return target;
+}
+
+size_t HTMLElement::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.HTMLElement)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated int32 child_ids = 3;
+  {
+    size_t data_size = ::_pbi::WireFormatLite::
+      Int32Size(this->_impl_.child_ids_);
+    total_size += 1 *
+                  ::_pbi::FromIntSize(this->_internal_child_ids_size());
+    total_size += data_size;
+  }
+
+  // repeated .safe_browsing.HTMLElement.Attribute attribute = 6;
+  total_size += 1UL * this->_internal_attribute_size();
+  for (const auto& msg : this->_impl_.attribute_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    // optional string tag = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_tag());
+    }
+
+    // optional int32 id = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_id());
+    }
+
+    // optional int32 resource_id = 5;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_resource_id());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void HTMLElement::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const HTMLElement*>(
+      &from));
+}
+
+void HTMLElement::MergeFrom(const HTMLElement& from) {
+  HTMLElement* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.HTMLElement)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  _this->_impl_.child_ids_.MergeFrom(from._impl_.child_ids_);
+  _this->_impl_.attribute_.MergeFrom(from._impl_.attribute_);
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000007u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_tag(from._internal_tag());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.id_ = from._impl_.id_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_impl_.resource_id_ = from._impl_.resource_id_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void HTMLElement::CopyFrom(const HTMLElement& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.HTMLElement)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool HTMLElement::IsInitialized() const {
+  return true;
+}
+
+void HTMLElement::InternalSwap(HTMLElement* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  _impl_.child_ids_.InternalSwap(&other->_impl_.child_ids_);
+  _impl_.attribute_.InternalSwap(&other->_impl_.attribute_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.tag_, lhs_arena,
+      &other->_impl_.tag_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(HTMLElement, _impl_.resource_id_)
+      + sizeof(HTMLElement::_impl_.resource_id_)
+      - PROTOBUF_FIELD_OFFSET(HTMLElement, _impl_.id_)>(
+          reinterpret_cast<char*>(&_impl_.id_),
+          reinterpret_cast<char*>(&other->_impl_.id_));
+}
+
+std::string HTMLElement::GetTypeName() const {
+  return "safe_browsing.HTMLElement";
+}
+
+
+// ===================================================================
+
+class ImageData_Dimensions::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ImageData_Dimensions>()._impl_._has_bits_);
+  static void set_has_width(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_height(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+ImageData_Dimensions::ImageData_Dimensions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ImageData.Dimensions)
+}
+ImageData_Dimensions::ImageData_Dimensions(const ImageData_Dimensions& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ImageData_Dimensions* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.width_){}
+    , decltype(_impl_.height_){}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::memcpy(&_impl_.width_, &from._impl_.width_,
+    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.height_) -
+    reinterpret_cast<char*>(&_impl_.width_)) + sizeof(_impl_.height_));
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ImageData.Dimensions)
+}
+
+inline void ImageData_Dimensions::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.width_){0}
+    , decltype(_impl_.height_){0}
+  };
+}
+
+ImageData_Dimensions::~ImageData_Dimensions() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ImageData.Dimensions)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ImageData_Dimensions::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ImageData_Dimensions::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ImageData_Dimensions::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ImageData.Dimensions)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    ::memset(&_impl_.width_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&_impl_.height_) -
+        reinterpret_cast<char*>(&_impl_.width_)) + sizeof(_impl_.height_));
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ImageData_Dimensions::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional int32 width = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _Internal::set_has_width(&has_bits);
+          _impl_.width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional int32 height = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _Internal::set_has_height(&has_bits);
+          _impl_.height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ImageData_Dimensions::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ImageData.Dimensions)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional int32 width = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_width(), target);
+  }
+
+  // optional int32 height = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_height(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ImageData.Dimensions)
+  return target;
+}
+
+size_t ImageData_Dimensions::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ImageData.Dimensions)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional int32 width = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_width());
+    }
+
+    // optional int32 height = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_height());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ImageData_Dimensions::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ImageData_Dimensions*>(
+      &from));
+}
+
+void ImageData_Dimensions::MergeFrom(const ImageData_Dimensions& from) {
+  ImageData_Dimensions* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ImageData.Dimensions)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_impl_.width_ = from._impl_.width_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_impl_.height_ = from._impl_.height_;
+    }
+    _this->_impl_._has_bits_[0] |= cached_has_bits;
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ImageData_Dimensions::CopyFrom(const ImageData_Dimensions& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ImageData.Dimensions)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ImageData_Dimensions::IsInitialized() const {
+  return true;
+}
+
+void ImageData_Dimensions::InternalSwap(ImageData_Dimensions* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ImageData_Dimensions, _impl_.height_)
+      + sizeof(ImageData_Dimensions::_impl_.height_)
+      - PROTOBUF_FIELD_OFFSET(ImageData_Dimensions, _impl_.width_)>(
+          reinterpret_cast<char*>(&_impl_.width_),
+          reinterpret_cast<char*>(&other->_impl_.width_));
+}
+
+std::string ImageData_Dimensions::GetTypeName() const {
+  return "safe_browsing.ImageData.Dimensions";
+}
+
+
+// ===================================================================
+
+class ImageData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<ImageData>()._impl_._has_bits_);
+  static void set_has_data(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_mime_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static const ::safe_browsing::ImageData_Dimensions& dimensions(const ImageData* msg);
+  static void set_has_dimensions(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static const ::safe_browsing::ImageData_Dimensions& original_dimensions(const ImageData* msg);
+  static void set_has_original_dimensions(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+const ::safe_browsing::ImageData_Dimensions&
+ImageData::_Internal::dimensions(const ImageData* msg) {
+  return *msg->_impl_.dimensions_;
+}
+const ::safe_browsing::ImageData_Dimensions&
+ImageData::_Internal::original_dimensions(const ImageData* msg) {
+  return *msg->_impl_.original_dimensions_;
+}
+ImageData::ImageData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.ImageData)
+}
+ImageData::ImageData(const ImageData& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  ImageData* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.data_){}
+    , decltype(_impl_.mime_type_){}
+    , decltype(_impl_.dimensions_){nullptr}
+    , decltype(_impl_.original_dimensions_){nullptr}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.data_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.data_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_data()) {
+    _this->_impl_.data_.Set(from._internal_data(),
+      _this->GetArenaForAllocation());
+  }
+  _impl_.mime_type_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mime_type_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_mime_type()) {
+    _this->_impl_.mime_type_.Set(from._internal_mime_type(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_dimensions()) {
+    _this->_impl_.dimensions_ = new ::safe_browsing::ImageData_Dimensions(*from._impl_.dimensions_);
+  }
+  if (from._internal_has_original_dimensions()) {
+    _this->_impl_.original_dimensions_ = new ::safe_browsing::ImageData_Dimensions(*from._impl_.original_dimensions_);
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ImageData)
+}
+
+inline void ImageData::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.data_){}
+    , decltype(_impl_.mime_type_){}
+    , decltype(_impl_.dimensions_){nullptr}
+    , decltype(_impl_.original_dimensions_){nullptr}
+  };
+  _impl_.data_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.data_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  _impl_.mime_type_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.mime_type_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ImageData::~ImageData() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ImageData)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void ImageData::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.data_.Destroy();
+  _impl_.mime_type_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.dimensions_;
+  if (this != internal_default_instance()) delete _impl_.original_dimensions_;
+}
+
+void ImageData::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void ImageData::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.ImageData)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.data_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _impl_.mime_type_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000004u) {
+      GOOGLE_DCHECK(_impl_.dimensions_ != nullptr);
+      _impl_.dimensions_->Clear();
+    }
+    if (cached_has_bits & 0x00000008u) {
+      GOOGLE_DCHECK(_impl_.original_dimensions_ != nullptr);
+      _impl_.original_dimensions_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* ImageData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional bytes data = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_data();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional string mime_type = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_mime_type();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ImageData.Dimensions dimensions = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_dimensions(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ImageData.Dimensions original_dimensions = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_original_dimensions(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ImageData::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ImageData)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional bytes data = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_data(), target);
+  }
+
+  // optional string mime_type = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_mime_type(), target);
+  }
+
+  // optional .safe_browsing.ImageData.Dimensions dimensions = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, _Internal::dimensions(this),
+        _Internal::dimensions(this).GetCachedSize(), target, stream);
+  }
+
+  // optional .safe_browsing.ImageData.Dimensions original_dimensions = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, _Internal::original_dimensions(this),
+        _Internal::original_dimensions(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.ImageData)
+  return target;
+}
+
+size_t ImageData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.ImageData)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // optional bytes data = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_data());
+    }
+
+    // optional string mime_type = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_mime_type());
+    }
+
+    // optional .safe_browsing.ImageData.Dimensions dimensions = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.dimensions_);
+    }
+
+    // optional .safe_browsing.ImageData.Dimensions original_dimensions = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.original_dimensions_);
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ImageData::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const ImageData*>(
+      &from));
+}
+
+void ImageData::MergeFrom(const ImageData& from) {
+  ImageData* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ImageData)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_data(from._internal_data());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_set_mime_type(from._internal_mime_type());
+    }
+    if (cached_has_bits & 0x00000004u) {
+      _this->_internal_mutable_dimensions()->::safe_browsing::ImageData_Dimensions::MergeFrom(
+          from._internal_dimensions());
+    }
+    if (cached_has_bits & 0x00000008u) {
+      _this->_internal_mutable_original_dimensions()->::safe_browsing::ImageData_Dimensions::MergeFrom(
+          from._internal_original_dimensions());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void ImageData::CopyFrom(const ImageData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.ImageData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ImageData::IsInitialized() const {
+  return true;
+}
+
+void ImageData::InternalSwap(ImageData* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.data_, lhs_arena,
+      &other->_impl_.data_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.mime_type_, lhs_arena,
+      &other->_impl_.mime_type_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ImageData, _impl_.original_dimensions_)
+      + sizeof(ImageData::_impl_.original_dimensions_)
+      - PROTOBUF_FIELD_OFFSET(ImageData, _impl_.dimensions_)>(
+          reinterpret_cast<char*>(&_impl_.dimensions_),
+          reinterpret_cast<char*>(&other->_impl_.dimensions_));
+}
+
+std::string ImageData::GetTypeName() const {
+  return "safe_browsing.ImageData";
+}
+
+
+// ===================================================================
+
+class NotificationImageReportRequest::_Internal {
+ public:
+  using HasBits = decltype(std::declval<NotificationImageReportRequest>()._impl_._has_bits_);
+  static void set_has_notification_origin(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static const ::safe_browsing::ImageData& image(const NotificationImageReportRequest* msg);
+  static void set_has_image(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+const ::safe_browsing::ImageData&
+NotificationImageReportRequest::_Internal::image(const NotificationImageReportRequest* msg) {
+  return *msg->_impl_.image_;
+}
+NotificationImageReportRequest::NotificationImageReportRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
+  SharedCtor(arena, is_message_owned);
+  // @@protoc_insertion_point(arena_constructor:safe_browsing.NotificationImageReportRequest)
+}
+NotificationImageReportRequest::NotificationImageReportRequest(const NotificationImageReportRequest& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  NotificationImageReportRequest* const _this = this; (void)_this;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){from._impl_._has_bits_}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.notification_origin_){}
+    , decltype(_impl_.image_){nullptr}};
+
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  _impl_.notification_origin_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.notification_origin_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (from._internal_has_notification_origin()) {
+    _this->_impl_.notification_origin_.Set(from._internal_notification_origin(),
+      _this->GetArenaForAllocation());
+  }
+  if (from._internal_has_image()) {
+    _this->_impl_.image_ = new ::safe_browsing::ImageData(*from._impl_.image_);
+  }
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.NotificationImageReportRequest)
+}
+
+inline void NotificationImageReportRequest::SharedCtor(
+    ::_pb::Arena* arena, bool is_message_owned) {
+  (void)arena;
+  (void)is_message_owned;
+  new (&_impl_) Impl_{
+      decltype(_impl_._has_bits_){}
+    , /*decltype(_impl_._cached_size_)*/{}
+    , decltype(_impl_.notification_origin_){}
+    , decltype(_impl_.image_){nullptr}
+  };
+  _impl_.notification_origin_.InitDefault();
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    _impl_.notification_origin_.Set("", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+NotificationImageReportRequest::~NotificationImageReportRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.NotificationImageReportRequest)
+  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
+  (void)arena;
+    return;
+  }
+  SharedDtor();
+}
+
+inline void NotificationImageReportRequest::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.notification_origin_.Destroy();
+  if (this != internal_default_instance()) delete _impl_.image_;
+}
+
+void NotificationImageReportRequest::SetCachedSize(int size) const {
+  _impl_._cached_size_.Set(size);
+}
+
+void NotificationImageReportRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:safe_browsing.NotificationImageReportRequest)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _impl_.notification_origin_.ClearNonDefaultToEmpty();
+    }
+    if (cached_has_bits & 0x00000002u) {
+      GOOGLE_DCHECK(_impl_.image_ != nullptr);
+      _impl_.image_->Clear();
+    }
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* NotificationImageReportRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::_pbi::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // optional string notification_origin = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_notification_origin();
+          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // optional .safe_browsing.ImageData image = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_image(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<std::string>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  _impl_._has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* NotificationImageReportRequest::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.NotificationImageReportRequest)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  // optional string notification_origin = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_notification_origin(), target);
+  }
+
+  // optional .safe_browsing.ImageData image = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, _Internal::image(this),
+        _Internal::image(this).GetCachedSize(), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:safe_browsing.NotificationImageReportRequest)
+  return target;
+}
+
+size_t NotificationImageReportRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:safe_browsing.NotificationImageReportRequest)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // optional string notification_origin = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_notification_origin());
+    }
+
+    // optional .safe_browsing.ImageData image = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *_impl_.image_);
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::_pbi::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void NotificationImageReportRequest::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::_pbi::DownCast<const NotificationImageReportRequest*>(
+      &from));
+}
+
+void NotificationImageReportRequest::MergeFrom(const NotificationImageReportRequest& from) {
+  NotificationImageReportRequest* const _this = this;
+  // @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.NotificationImageReportRequest)
+  GOOGLE_DCHECK_NE(&from, _this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      _this->_internal_set_notification_origin(from._internal_notification_origin());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      _this->_internal_mutable_image()->::safe_browsing::ImageData::MergeFrom(
+          from._internal_image());
+    }
+  }
+  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+}
+
+void NotificationImageReportRequest::CopyFrom(const NotificationImageReportRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:safe_browsing.NotificationImageReportRequest)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool NotificationImageReportRequest::IsInitialized() const {
+  return true;
+}
+
+void NotificationImageReportRequest::InternalSwap(NotificationImageReportRequest* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &_impl_.notification_origin_, lhs_arena,
+      &other->_impl_.notification_origin_, rhs_arena
+  );
+  swap(_impl_.image_, other->_impl_.image_);
+}
+
+std::string NotificationImageReportRequest::GetTypeName() const {
+  return "safe_browsing.NotificationImageReportRequest";
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace safe_browsing
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::safe_browsing::ChromeUserPopulation*
+Arena::CreateMaybeMessage< ::safe_browsing::ChromeUserPopulation >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ChromeUserPopulation >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientPhishingRequest_Feature*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientPhishingRequest_Feature >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientPhishingRequest_Feature >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientPhishingRequest*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientPhishingRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientPhishingRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientPhishingResponse*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientPhishingResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientPhishingResponse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientMalwareRequest_UrlInfo*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientMalwareRequest_UrlInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientMalwareRequest_UrlInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientMalwareRequest*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientMalwareRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientMalwareRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::LoginReputationClientRequest_Frame_Form*
+Arena::CreateMaybeMessage< ::safe_browsing::LoginReputationClientRequest_Frame_Form >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::LoginReputationClientRequest_Frame_Form >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::LoginReputationClientRequest_Frame*
+Arena::CreateMaybeMessage< ::safe_browsing::LoginReputationClientRequest_Frame >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::LoginReputationClientRequest_Frame >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent*
+Arena::CreateMaybeMessage< ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::LoginReputationClientRequest*
+Arena::CreateMaybeMessage< ::safe_browsing::LoginReputationClientRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::LoginReputationClientRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::LoginReputationClientResponse*
+Arena::CreateMaybeMessage< ::safe_browsing::LoginReputationClientResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::LoginReputationClientResponse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientMalwareResponse*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientMalwareResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientMalwareResponse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_Digests*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_Digests >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadRequest_Digests >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_Resource*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_Resource >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadRequest_Resource >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_CertificateChain_Element*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_CertificateChain*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_CertificateChain >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadRequest_CertificateChain >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_ExtendedAttr*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_ExtendedAttr >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadRequest_ExtendedAttr >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_SignatureInfo*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_SignatureInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadRequest_SignatureInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_PEImageHeaders*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_PEImageHeaders >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadRequest_PEImageHeaders >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_MachOHeaders*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_MachOHeaders >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadRequest_MachOHeaders >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_ImageHeaders*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_ImageHeaders >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadRequest_ImageHeaders >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_ArchivedBinary*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_ArchivedBinary >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadRequest_ArchivedBinary >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ReferrerChainEntry_ServerRedirect*
+Arena::CreateMaybeMessage< ::safe_browsing::ReferrerChainEntry_ServerRedirect >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ReferrerChainEntry_ServerRedirect >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ReferrerChainEntry*
+Arena::CreateMaybeMessage< ::safe_browsing::ReferrerChainEntry >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ReferrerChainEntry >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadResponse_MoreInfo*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadResponse_MoreInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadResponse_MoreInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadResponse*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadResponse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadReport_UserInformation*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadReport_UserInformation >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadReport_UserInformation >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadReport*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadReport >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientDownloadReport >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientUploadResponse*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientUploadResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientUploadResponse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_IncidentData*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_IncidentData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_IncidentData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_DownloadDetails*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_DownloadDetails >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_DownloadDetails >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_EnvironmentData_OS*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_EnvironmentData_Process*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_EnvironmentData*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_EnvironmentData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_EnvironmentData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_ExtensionData*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_ExtensionData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_ExtensionData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentReport >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentResponse_EnvironmentRequest*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentResponse*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientIncidentResponse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::DownloadMetadata*
+Arena::CreateMaybeMessage< ::safe_browsing::DownloadMetadata >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::DownloadMetadata >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_Resource*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest*
+Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ClientSafeBrowsingReportRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::HTMLElement_Attribute*
+Arena::CreateMaybeMessage< ::safe_browsing::HTMLElement_Attribute >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::HTMLElement_Attribute >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::HTMLElement*
+Arena::CreateMaybeMessage< ::safe_browsing::HTMLElement >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::HTMLElement >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ImageData_Dimensions*
+Arena::CreateMaybeMessage< ::safe_browsing::ImageData_Dimensions >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ImageData_Dimensions >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::ImageData*
+Arena::CreateMaybeMessage< ::safe_browsing::ImageData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::ImageData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::safe_browsing::NotificationImageReportRequest*
+Arena::CreateMaybeMessage< ::safe_browsing::NotificationImageReportRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::safe_browsing::NotificationImageReportRequest >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.pb.h b/toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.pb.h
new file mode 100644
index 0000000000..a38c8f4c3e
--- /dev/null
+++ b/toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.pb.h
@@ -0,0 +1,32434 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: csd.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_csd_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_csd_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#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 3021006 < 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/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_util.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_csd_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_csd_2eproto {
+  static const uint32_t offsets[];
+};
+namespace safe_browsing {
+class ChromeUserPopulation;
+struct ChromeUserPopulationDefaultTypeInternal;
+extern ChromeUserPopulationDefaultTypeInternal _ChromeUserPopulation_default_instance_;
+class ClientDownloadReport;
+struct ClientDownloadReportDefaultTypeInternal;
+extern ClientDownloadReportDefaultTypeInternal _ClientDownloadReport_default_instance_;
+class ClientDownloadReport_UserInformation;
+struct ClientDownloadReport_UserInformationDefaultTypeInternal;
+extern ClientDownloadReport_UserInformationDefaultTypeInternal _ClientDownloadReport_UserInformation_default_instance_;
+class ClientDownloadRequest;
+struct ClientDownloadRequestDefaultTypeInternal;
+extern ClientDownloadRequestDefaultTypeInternal _ClientDownloadRequest_default_instance_;
+class ClientDownloadRequest_ArchivedBinary;
+struct ClientDownloadRequest_ArchivedBinaryDefaultTypeInternal;
+extern ClientDownloadRequest_ArchivedBinaryDefaultTypeInternal _ClientDownloadRequest_ArchivedBinary_default_instance_;
+class ClientDownloadRequest_CertificateChain;
+struct ClientDownloadRequest_CertificateChainDefaultTypeInternal;
+extern ClientDownloadRequest_CertificateChainDefaultTypeInternal _ClientDownloadRequest_CertificateChain_default_instance_;
+class ClientDownloadRequest_CertificateChain_Element;
+struct ClientDownloadRequest_CertificateChain_ElementDefaultTypeInternal;
+extern ClientDownloadRequest_CertificateChain_ElementDefaultTypeInternal _ClientDownloadRequest_CertificateChain_Element_default_instance_;
+class ClientDownloadRequest_Digests;
+struct ClientDownloadRequest_DigestsDefaultTypeInternal;
+extern ClientDownloadRequest_DigestsDefaultTypeInternal _ClientDownloadRequest_Digests_default_instance_;
+class ClientDownloadRequest_ExtendedAttr;
+struct ClientDownloadRequest_ExtendedAttrDefaultTypeInternal;
+extern ClientDownloadRequest_ExtendedAttrDefaultTypeInternal _ClientDownloadRequest_ExtendedAttr_default_instance_;
+class ClientDownloadRequest_ImageHeaders;
+struct ClientDownloadRequest_ImageHeadersDefaultTypeInternal;
+extern ClientDownloadRequest_ImageHeadersDefaultTypeInternal _ClientDownloadRequest_ImageHeaders_default_instance_;
+class ClientDownloadRequest_MachOHeaders;
+struct ClientDownloadRequest_MachOHeadersDefaultTypeInternal;
+extern ClientDownloadRequest_MachOHeadersDefaultTypeInternal _ClientDownloadRequest_MachOHeaders_default_instance_;
+class ClientDownloadRequest_MachOHeaders_LoadCommand;
+struct ClientDownloadRequest_MachOHeaders_LoadCommandDefaultTypeInternal;
+extern ClientDownloadRequest_MachOHeaders_LoadCommandDefaultTypeInternal _ClientDownloadRequest_MachOHeaders_LoadCommand_default_instance_;
+class ClientDownloadRequest_PEImageHeaders;
+struct ClientDownloadRequest_PEImageHeadersDefaultTypeInternal;
+extern ClientDownloadRequest_PEImageHeadersDefaultTypeInternal _ClientDownloadRequest_PEImageHeaders_default_instance_;
+class ClientDownloadRequest_PEImageHeaders_DebugData;
+struct ClientDownloadRequest_PEImageHeaders_DebugDataDefaultTypeInternal;
+extern ClientDownloadRequest_PEImageHeaders_DebugDataDefaultTypeInternal _ClientDownloadRequest_PEImageHeaders_DebugData_default_instance_;
+class ClientDownloadRequest_Resource;
+struct ClientDownloadRequest_ResourceDefaultTypeInternal;
+extern ClientDownloadRequest_ResourceDefaultTypeInternal _ClientDownloadRequest_Resource_default_instance_;
+class ClientDownloadRequest_SignatureInfo;
+struct ClientDownloadRequest_SignatureInfoDefaultTypeInternal;
+extern ClientDownloadRequest_SignatureInfoDefaultTypeInternal _ClientDownloadRequest_SignatureInfo_default_instance_;
+class ClientDownloadResponse;
+struct ClientDownloadResponseDefaultTypeInternal;
+extern ClientDownloadResponseDefaultTypeInternal _ClientDownloadResponse_default_instance_;
+class ClientDownloadResponse_MoreInfo;
+struct ClientDownloadResponse_MoreInfoDefaultTypeInternal;
+extern ClientDownloadResponse_MoreInfoDefaultTypeInternal _ClientDownloadResponse_MoreInfo_default_instance_;
+class ClientIncidentReport;
+struct ClientIncidentReportDefaultTypeInternal;
+extern ClientIncidentReportDefaultTypeInternal _ClientIncidentReport_default_instance_;
+class ClientIncidentReport_DownloadDetails;
+struct ClientIncidentReport_DownloadDetailsDefaultTypeInternal;
+extern ClientIncidentReport_DownloadDetailsDefaultTypeInternal _ClientIncidentReport_DownloadDetails_default_instance_;
+class ClientIncidentReport_EnvironmentData;
+struct ClientIncidentReport_EnvironmentDataDefaultTypeInternal;
+extern ClientIncidentReport_EnvironmentDataDefaultTypeInternal _ClientIncidentReport_EnvironmentData_default_instance_;
+class ClientIncidentReport_EnvironmentData_Machine;
+struct ClientIncidentReport_EnvironmentData_MachineDefaultTypeInternal;
+extern ClientIncidentReport_EnvironmentData_MachineDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Machine_default_instance_;
+class ClientIncidentReport_EnvironmentData_OS;
+struct ClientIncidentReport_EnvironmentData_OSDefaultTypeInternal;
+extern ClientIncidentReport_EnvironmentData_OSDefaultTypeInternal _ClientIncidentReport_EnvironmentData_OS_default_instance_;
+class ClientIncidentReport_EnvironmentData_OS_RegistryKey;
+struct ClientIncidentReport_EnvironmentData_OS_RegistryKeyDefaultTypeInternal;
+extern ClientIncidentReport_EnvironmentData_OS_RegistryKeyDefaultTypeInternal _ClientIncidentReport_EnvironmentData_OS_RegistryKey_default_instance_;
+class ClientIncidentReport_EnvironmentData_OS_RegistryValue;
+struct ClientIncidentReport_EnvironmentData_OS_RegistryValueDefaultTypeInternal;
+extern ClientIncidentReport_EnvironmentData_OS_RegistryValueDefaultTypeInternal _ClientIncidentReport_EnvironmentData_OS_RegistryValue_default_instance_;
+class ClientIncidentReport_EnvironmentData_Process;
+struct ClientIncidentReport_EnvironmentData_ProcessDefaultTypeInternal;
+extern ClientIncidentReport_EnvironmentData_ProcessDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_default_instance_;
+class ClientIncidentReport_EnvironmentData_Process_Dll;
+struct ClientIncidentReport_EnvironmentData_Process_DllDefaultTypeInternal;
+extern ClientIncidentReport_EnvironmentData_Process_DllDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_Dll_default_instance_;
+class ClientIncidentReport_EnvironmentData_Process_ModuleState;
+struct ClientIncidentReport_EnvironmentData_Process_ModuleStateDefaultTypeInternal;
+extern ClientIncidentReport_EnvironmentData_Process_ModuleStateDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_ModuleState_default_instance_;
+class ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification;
+struct ClientIncidentReport_EnvironmentData_Process_ModuleState_ModificationDefaultTypeInternal;
+extern ClientIncidentReport_EnvironmentData_Process_ModuleState_ModificationDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification_default_instance_;
+class ClientIncidentReport_EnvironmentData_Process_NetworkProvider;
+struct ClientIncidentReport_EnvironmentData_Process_NetworkProviderDefaultTypeInternal;
+extern ClientIncidentReport_EnvironmentData_Process_NetworkProviderDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_NetworkProvider_default_instance_;
+class ClientIncidentReport_EnvironmentData_Process_Patch;
+struct ClientIncidentReport_EnvironmentData_Process_PatchDefaultTypeInternal;
+extern ClientIncidentReport_EnvironmentData_Process_PatchDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_Patch_default_instance_;
+class ClientIncidentReport_ExtensionData;
+struct ClientIncidentReport_ExtensionDataDefaultTypeInternal;
+extern ClientIncidentReport_ExtensionDataDefaultTypeInternal _ClientIncidentReport_ExtensionData_default_instance_;
+class ClientIncidentReport_ExtensionData_ExtensionInfo;
+struct ClientIncidentReport_ExtensionData_ExtensionInfoDefaultTypeInternal;
+extern ClientIncidentReport_ExtensionData_ExtensionInfoDefaultTypeInternal _ClientIncidentReport_ExtensionData_ExtensionInfo_default_instance_;
+class ClientIncidentReport_IncidentData;
+struct ClientIncidentReport_IncidentDataDefaultTypeInternal;
+extern ClientIncidentReport_IncidentDataDefaultTypeInternal _ClientIncidentReport_IncidentData_default_instance_;
+class ClientIncidentReport_IncidentData_BinaryIntegrityIncident;
+struct ClientIncidentReport_IncidentData_BinaryIntegrityIncidentDefaultTypeInternal;
+extern ClientIncidentReport_IncidentData_BinaryIntegrityIncidentDefaultTypeInternal _ClientIncidentReport_IncidentData_BinaryIntegrityIncident_default_instance_;
+class ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile;
+struct ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFileDefaultTypeInternal;
+extern ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFileDefaultTypeInternal _ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_default_instance_;
+class ClientIncidentReport_IncidentData_ResourceRequestIncident;
+struct ClientIncidentReport_IncidentData_ResourceRequestIncidentDefaultTypeInternal;
+extern ClientIncidentReport_IncidentData_ResourceRequestIncidentDefaultTypeInternal _ClientIncidentReport_IncidentData_ResourceRequestIncident_default_instance_;
+class ClientIncidentReport_IncidentData_TrackedPreferenceIncident;
+struct ClientIncidentReport_IncidentData_TrackedPreferenceIncidentDefaultTypeInternal;
+extern ClientIncidentReport_IncidentData_TrackedPreferenceIncidentDefaultTypeInternal _ClientIncidentReport_IncidentData_TrackedPreferenceIncident_default_instance_;
+class ClientIncidentReport_NonBinaryDownloadDetails;
+struct ClientIncidentReport_NonBinaryDownloadDetailsDefaultTypeInternal;
+extern ClientIncidentReport_NonBinaryDownloadDetailsDefaultTypeInternal _ClientIncidentReport_NonBinaryDownloadDetails_default_instance_;
+class ClientIncidentResponse;
+struct ClientIncidentResponseDefaultTypeInternal;
+extern ClientIncidentResponseDefaultTypeInternal _ClientIncidentResponse_default_instance_;
+class ClientIncidentResponse_EnvironmentRequest;
+struct ClientIncidentResponse_EnvironmentRequestDefaultTypeInternal;
+extern ClientIncidentResponse_EnvironmentRequestDefaultTypeInternal _ClientIncidentResponse_EnvironmentRequest_default_instance_;
+class ClientMalwareRequest;
+struct ClientMalwareRequestDefaultTypeInternal;
+extern ClientMalwareRequestDefaultTypeInternal _ClientMalwareRequest_default_instance_;
+class ClientMalwareRequest_UrlInfo;
+struct ClientMalwareRequest_UrlInfoDefaultTypeInternal;
+extern ClientMalwareRequest_UrlInfoDefaultTypeInternal _ClientMalwareRequest_UrlInfo_default_instance_;
+class ClientMalwareResponse;
+struct ClientMalwareResponseDefaultTypeInternal;
+extern ClientMalwareResponseDefaultTypeInternal _ClientMalwareResponse_default_instance_;
+class ClientPhishingRequest;
+struct ClientPhishingRequestDefaultTypeInternal;
+extern ClientPhishingRequestDefaultTypeInternal _ClientPhishingRequest_default_instance_;
+class ClientPhishingRequest_Feature;
+struct ClientPhishingRequest_FeatureDefaultTypeInternal;
+extern ClientPhishingRequest_FeatureDefaultTypeInternal _ClientPhishingRequest_Feature_default_instance_;
+class ClientPhishingResponse;
+struct ClientPhishingResponseDefaultTypeInternal;
+extern ClientPhishingResponseDefaultTypeInternal _ClientPhishingResponse_default_instance_;
+class ClientSafeBrowsingReportRequest;
+struct ClientSafeBrowsingReportRequestDefaultTypeInternal;
+extern ClientSafeBrowsingReportRequestDefaultTypeInternal _ClientSafeBrowsingReportRequest_default_instance_;
+class ClientSafeBrowsingReportRequest_HTTPHeader;
+struct ClientSafeBrowsingReportRequest_HTTPHeaderDefaultTypeInternal;
+extern ClientSafeBrowsingReportRequest_HTTPHeaderDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPHeader_default_instance_;
+class ClientSafeBrowsingReportRequest_HTTPRequest;
+struct ClientSafeBrowsingReportRequest_HTTPRequestDefaultTypeInternal;
+extern ClientSafeBrowsingReportRequest_HTTPRequestDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPRequest_default_instance_;
+class ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine;
+struct ClientSafeBrowsingReportRequest_HTTPRequest_FirstLineDefaultTypeInternal;
+extern ClientSafeBrowsingReportRequest_HTTPRequest_FirstLineDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_default_instance_;
+class ClientSafeBrowsingReportRequest_HTTPResponse;
+struct ClientSafeBrowsingReportRequest_HTTPResponseDefaultTypeInternal;
+extern ClientSafeBrowsingReportRequest_HTTPResponseDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPResponse_default_instance_;
+class ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine;
+struct ClientSafeBrowsingReportRequest_HTTPResponse_FirstLineDefaultTypeInternal;
+extern ClientSafeBrowsingReportRequest_HTTPResponse_FirstLineDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_default_instance_;
+class ClientSafeBrowsingReportRequest_Resource;
+struct ClientSafeBrowsingReportRequest_ResourceDefaultTypeInternal;
+extern ClientSafeBrowsingReportRequest_ResourceDefaultTypeInternal _ClientSafeBrowsingReportRequest_Resource_default_instance_;
+class ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties;
+struct ClientSafeBrowsingReportRequest_SafeBrowsingClientPropertiesDefaultTypeInternal;
+extern ClientSafeBrowsingReportRequest_SafeBrowsingClientPropertiesDefaultTypeInternal _ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_default_instance_;
+class ClientUploadResponse;
+struct ClientUploadResponseDefaultTypeInternal;
+extern ClientUploadResponseDefaultTypeInternal _ClientUploadResponse_default_instance_;
+class DownloadMetadata;
+struct DownloadMetadataDefaultTypeInternal;
+extern DownloadMetadataDefaultTypeInternal _DownloadMetadata_default_instance_;
+class HTMLElement;
+struct HTMLElementDefaultTypeInternal;
+extern HTMLElementDefaultTypeInternal _HTMLElement_default_instance_;
+class HTMLElement_Attribute;
+struct HTMLElement_AttributeDefaultTypeInternal;
+extern HTMLElement_AttributeDefaultTypeInternal _HTMLElement_Attribute_default_instance_;
+class ImageData;
+struct ImageDataDefaultTypeInternal;
+extern ImageDataDefaultTypeInternal _ImageData_default_instance_;
+class ImageData_Dimensions;
+struct ImageData_DimensionsDefaultTypeInternal;
+extern ImageData_DimensionsDefaultTypeInternal _ImageData_Dimensions_default_instance_;
+class LoginReputationClientRequest;
+struct LoginReputationClientRequestDefaultTypeInternal;
+extern LoginReputationClientRequestDefaultTypeInternal _LoginReputationClientRequest_default_instance_;
+class LoginReputationClientRequest_Frame;
+struct LoginReputationClientRequest_FrameDefaultTypeInternal;
+extern LoginReputationClientRequest_FrameDefaultTypeInternal _LoginReputationClientRequest_Frame_default_instance_;
+class LoginReputationClientRequest_Frame_Form;
+struct LoginReputationClientRequest_Frame_FormDefaultTypeInternal;
+extern LoginReputationClientRequest_Frame_FormDefaultTypeInternal _LoginReputationClientRequest_Frame_Form_default_instance_;
+class LoginReputationClientRequest_PasswordReuseEvent;
+struct LoginReputationClientRequest_PasswordReuseEventDefaultTypeInternal;
+extern LoginReputationClientRequest_PasswordReuseEventDefaultTypeInternal _LoginReputationClientRequest_PasswordReuseEvent_default_instance_;
+class LoginReputationClientResponse;
+struct LoginReputationClientResponseDefaultTypeInternal;
+extern LoginReputationClientResponseDefaultTypeInternal _LoginReputationClientResponse_default_instance_;
+class NotificationImageReportRequest;
+struct NotificationImageReportRequestDefaultTypeInternal;
+extern NotificationImageReportRequestDefaultTypeInternal _NotificationImageReportRequest_default_instance_;
+class ReferrerChainEntry;
+struct ReferrerChainEntryDefaultTypeInternal;
+extern ReferrerChainEntryDefaultTypeInternal _ReferrerChainEntry_default_instance_;
+class ReferrerChainEntry_ServerRedirect;
+struct ReferrerChainEntry_ServerRedirectDefaultTypeInternal;
+extern ReferrerChainEntry_ServerRedirectDefaultTypeInternal _ReferrerChainEntry_ServerRedirect_default_instance_;
+}  // namespace safe_browsing
+PROTOBUF_NAMESPACE_OPEN
+template<> ::safe_browsing::ChromeUserPopulation* Arena::CreateMaybeMessage<::safe_browsing::ChromeUserPopulation>(Arena*);
+template<> ::safe_browsing::ClientDownloadReport* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadReport>(Arena*);
+template<> ::safe_browsing::ClientDownloadReport_UserInformation* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadReport_UserInformation>(Arena*);
+template<> ::safe_browsing::ClientDownloadRequest* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadRequest>(Arena*);
+template<> ::safe_browsing::ClientDownloadRequest_ArchivedBinary* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_ArchivedBinary>(Arena*);
+template<> ::safe_browsing::ClientDownloadRequest_CertificateChain* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_CertificateChain>(Arena*);
+template<> ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_CertificateChain_Element>(Arena*);
+template<> ::safe_browsing::ClientDownloadRequest_Digests* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_Digests>(Arena*);
+template<> ::safe_browsing::ClientDownloadRequest_ExtendedAttr* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_ExtendedAttr>(Arena*);
+template<> ::safe_browsing::ClientDownloadRequest_ImageHeaders* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_ImageHeaders>(Arena*);
+template<> ::safe_browsing::ClientDownloadRequest_MachOHeaders* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_MachOHeaders>(Arena*);
+template<> ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand>(Arena*);
+template<> ::safe_browsing::ClientDownloadRequest_PEImageHeaders* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_PEImageHeaders>(Arena*);
+template<> ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData>(Arena*);
+template<> ::safe_browsing::ClientDownloadRequest_Resource* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_Resource>(Arena*);
+template<> ::safe_browsing::ClientDownloadRequest_SignatureInfo* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_SignatureInfo>(Arena*);
+template<> ::safe_browsing::ClientDownloadResponse* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadResponse>(Arena*);
+template<> ::safe_browsing::ClientDownloadResponse_MoreInfo* Arena::CreateMaybeMessage<::safe_browsing::ClientDownloadResponse_MoreInfo>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_DownloadDetails* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_DownloadDetails>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_EnvironmentData* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_Machine>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_OS>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_Process>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_ExtensionData* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_ExtensionData>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_IncidentData* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_IncidentData>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident>(Arena*);
+template<> ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails>(Arena*);
+template<> ::safe_browsing::ClientIncidentResponse* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentResponse>(Arena*);
+template<> ::safe_browsing::ClientIncidentResponse_EnvironmentRequest* Arena::CreateMaybeMessage<::safe_browsing::ClientIncidentResponse_EnvironmentRequest>(Arena*);
+template<> ::safe_browsing::ClientMalwareRequest* Arena::CreateMaybeMessage<::safe_browsing::ClientMalwareRequest>(Arena*);
+template<> ::safe_browsing::ClientMalwareRequest_UrlInfo* Arena::CreateMaybeMessage<::safe_browsing::ClientMalwareRequest_UrlInfo>(Arena*);
+template<> ::safe_browsing::ClientMalwareResponse* Arena::CreateMaybeMessage<::safe_browsing::ClientMalwareResponse>(Arena*);
+template<> ::safe_browsing::ClientPhishingRequest* Arena::CreateMaybeMessage<::safe_browsing::ClientPhishingRequest>(Arena*);
+template<> ::safe_browsing::ClientPhishingRequest_Feature* Arena::CreateMaybeMessage<::safe_browsing::ClientPhishingRequest_Feature>(Arena*);
+template<> ::safe_browsing::ClientPhishingResponse* Arena::CreateMaybeMessage<::safe_browsing::ClientPhishingResponse>(Arena*);
+template<> ::safe_browsing::ClientSafeBrowsingReportRequest* Arena::CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest>(Arena*);
+template<> ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* Arena::CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader>(Arena*);
+template<> ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* Arena::CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest>(Arena*);
+template<> ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* Arena::CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine>(Arena*);
+template<> ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* Arena::CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse>(Arena*);
+template<> ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* Arena::CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine>(Arena*);
+template<> ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* Arena::CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_Resource>(Arena*);
+template<> ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* Arena::CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties>(Arena*);
+template<> ::safe_browsing::ClientUploadResponse* Arena::CreateMaybeMessage<::safe_browsing::ClientUploadResponse>(Arena*);
+template<> ::safe_browsing::DownloadMetadata* Arena::CreateMaybeMessage<::safe_browsing::DownloadMetadata>(Arena*);
+template<> ::safe_browsing::HTMLElement* Arena::CreateMaybeMessage<::safe_browsing::HTMLElement>(Arena*);
+template<> ::safe_browsing::HTMLElement_Attribute* Arena::CreateMaybeMessage<::safe_browsing::HTMLElement_Attribute>(Arena*);
+template<> ::safe_browsing::ImageData* Arena::CreateMaybeMessage<::safe_browsing::ImageData>(Arena*);
+template<> ::safe_browsing::ImageData_Dimensions* Arena::CreateMaybeMessage<::safe_browsing::ImageData_Dimensions>(Arena*);
+template<> ::safe_browsing::LoginReputationClientRequest* Arena::CreateMaybeMessage<::safe_browsing::LoginReputationClientRequest>(Arena*);
+template<> ::safe_browsing::LoginReputationClientRequest_Frame* Arena::CreateMaybeMessage<::safe_browsing::LoginReputationClientRequest_Frame>(Arena*);
+template<> ::safe_browsing::LoginReputationClientRequest_Frame_Form* Arena::CreateMaybeMessage<::safe_browsing::LoginReputationClientRequest_Frame_Form>(Arena*);
+template<> ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* Arena::CreateMaybeMessage<::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent>(Arena*);
+template<> ::safe_browsing::LoginReputationClientResponse* Arena::CreateMaybeMessage<::safe_browsing::LoginReputationClientResponse>(Arena*);
+template<> ::safe_browsing::NotificationImageReportRequest* Arena::CreateMaybeMessage<::safe_browsing::NotificationImageReportRequest>(Arena*);
+template<> ::safe_browsing::ReferrerChainEntry* Arena::CreateMaybeMessage<::safe_browsing::ReferrerChainEntry>(Arena*);
+template<> ::safe_browsing::ReferrerChainEntry_ServerRedirect* Arena::CreateMaybeMessage<::safe_browsing::ReferrerChainEntry_ServerRedirect>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace safe_browsing {
+
+enum ChromeUserPopulation_UserPopulation : int {
+  ChromeUserPopulation_UserPopulation_UNKNOWN_USER_POPULATION = 0,
+  ChromeUserPopulation_UserPopulation_SAFE_BROWSING = 1,
+  ChromeUserPopulation_UserPopulation_EXTENDED_REPORTING = 2
+};
+bool ChromeUserPopulation_UserPopulation_IsValid(int value);
+constexpr ChromeUserPopulation_UserPopulation ChromeUserPopulation_UserPopulation_UserPopulation_MIN = ChromeUserPopulation_UserPopulation_UNKNOWN_USER_POPULATION;
+constexpr ChromeUserPopulation_UserPopulation ChromeUserPopulation_UserPopulation_UserPopulation_MAX = ChromeUserPopulation_UserPopulation_EXTENDED_REPORTING;
+constexpr int ChromeUserPopulation_UserPopulation_UserPopulation_ARRAYSIZE = ChromeUserPopulation_UserPopulation_UserPopulation_MAX + 1;
+
+const std::string& ChromeUserPopulation_UserPopulation_Name(ChromeUserPopulation_UserPopulation value);
+template<typename T>
+inline const std::string& ChromeUserPopulation_UserPopulation_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ChromeUserPopulation_UserPopulation>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ChromeUserPopulation_UserPopulation_Name.");
+  return ChromeUserPopulation_UserPopulation_Name(static_cast<ChromeUserPopulation_UserPopulation>(enum_t_value));
+}
+bool ChromeUserPopulation_UserPopulation_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeUserPopulation_UserPopulation* value);
+enum LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType : int {
+  LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_NOT_SIGNED_IN = 0,
+  LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_GMAIL = 1,
+  LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_GSUITE = 2
+};
+bool LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_IsValid(int value);
+constexpr LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_SyncAccountType_MIN = LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_NOT_SIGNED_IN;
+constexpr LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_SyncAccountType_MAX = LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_GSUITE;
+constexpr int LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_SyncAccountType_ARRAYSIZE = LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_SyncAccountType_MAX + 1;
+
+const std::string& LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_Name(LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType value);
+template<typename T>
+inline const std::string& LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_Name.");
+  return LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_Name(static_cast<LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType>(enum_t_value));
+}
+bool LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType* value);
+enum LoginReputationClientRequest_TriggerType : int {
+  LoginReputationClientRequest_TriggerType_TRIGGER_TYPE_UNSPECIFIED = 0,
+  LoginReputationClientRequest_TriggerType_UNFAMILIAR_LOGIN_PAGE = 1,
+  LoginReputationClientRequest_TriggerType_PASSWORD_REUSE_EVENT = 2
+};
+bool LoginReputationClientRequest_TriggerType_IsValid(int value);
+constexpr LoginReputationClientRequest_TriggerType LoginReputationClientRequest_TriggerType_TriggerType_MIN = LoginReputationClientRequest_TriggerType_TRIGGER_TYPE_UNSPECIFIED;
+constexpr LoginReputationClientRequest_TriggerType LoginReputationClientRequest_TriggerType_TriggerType_MAX = LoginReputationClientRequest_TriggerType_PASSWORD_REUSE_EVENT;
+constexpr int LoginReputationClientRequest_TriggerType_TriggerType_ARRAYSIZE = LoginReputationClientRequest_TriggerType_TriggerType_MAX + 1;
+
+const std::string& LoginReputationClientRequest_TriggerType_Name(LoginReputationClientRequest_TriggerType value);
+template<typename T>
+inline const std::string& LoginReputationClientRequest_TriggerType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, LoginReputationClientRequest_TriggerType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function LoginReputationClientRequest_TriggerType_Name.");
+  return LoginReputationClientRequest_TriggerType_Name(static_cast<LoginReputationClientRequest_TriggerType>(enum_t_value));
+}
+bool LoginReputationClientRequest_TriggerType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LoginReputationClientRequest_TriggerType* value);
+enum LoginReputationClientResponse_VerdictType : int {
+  LoginReputationClientResponse_VerdictType_VERDICT_TYPE_UNSPECIFIED = 0,
+  LoginReputationClientResponse_VerdictType_SAFE = 1,
+  LoginReputationClientResponse_VerdictType_LOW_REPUTATION = 2,
+  LoginReputationClientResponse_VerdictType_PHISHING = 3
+};
+bool LoginReputationClientResponse_VerdictType_IsValid(int value);
+constexpr LoginReputationClientResponse_VerdictType LoginReputationClientResponse_VerdictType_VerdictType_MIN = LoginReputationClientResponse_VerdictType_VERDICT_TYPE_UNSPECIFIED;
+constexpr LoginReputationClientResponse_VerdictType LoginReputationClientResponse_VerdictType_VerdictType_MAX = LoginReputationClientResponse_VerdictType_PHISHING;
+constexpr int LoginReputationClientResponse_VerdictType_VerdictType_ARRAYSIZE = LoginReputationClientResponse_VerdictType_VerdictType_MAX + 1;
+
+const std::string& LoginReputationClientResponse_VerdictType_Name(LoginReputationClientResponse_VerdictType value);
+template<typename T>
+inline const std::string& LoginReputationClientResponse_VerdictType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, LoginReputationClientResponse_VerdictType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function LoginReputationClientResponse_VerdictType_Name.");
+  return LoginReputationClientResponse_VerdictType_Name(static_cast<LoginReputationClientResponse_VerdictType>(enum_t_value));
+}
+bool LoginReputationClientResponse_VerdictType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LoginReputationClientResponse_VerdictType* value);
+enum ClientDownloadRequest_ResourceType : int {
+  ClientDownloadRequest_ResourceType_DOWNLOAD_URL = 0,
+  ClientDownloadRequest_ResourceType_DOWNLOAD_REDIRECT = 1,
+  ClientDownloadRequest_ResourceType_TAB_URL = 2,
+  ClientDownloadRequest_ResourceType_TAB_REDIRECT = 3,
+  ClientDownloadRequest_ResourceType_PPAPI_DOCUMENT = 4,
+  ClientDownloadRequest_ResourceType_PPAPI_PLUGIN = 5
+};
+bool ClientDownloadRequest_ResourceType_IsValid(int value);
+constexpr ClientDownloadRequest_ResourceType ClientDownloadRequest_ResourceType_ResourceType_MIN = ClientDownloadRequest_ResourceType_DOWNLOAD_URL;
+constexpr ClientDownloadRequest_ResourceType ClientDownloadRequest_ResourceType_ResourceType_MAX = ClientDownloadRequest_ResourceType_PPAPI_PLUGIN;
+constexpr int ClientDownloadRequest_ResourceType_ResourceType_ARRAYSIZE = ClientDownloadRequest_ResourceType_ResourceType_MAX + 1;
+
+const std::string& ClientDownloadRequest_ResourceType_Name(ClientDownloadRequest_ResourceType value);
+template<typename T>
+inline const std::string& ClientDownloadRequest_ResourceType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientDownloadRequest_ResourceType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientDownloadRequest_ResourceType_Name.");
+  return ClientDownloadRequest_ResourceType_Name(static_cast<ClientDownloadRequest_ResourceType>(enum_t_value));
+}
+bool ClientDownloadRequest_ResourceType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientDownloadRequest_ResourceType* value);
+enum ClientDownloadRequest_DownloadType : int {
+  ClientDownloadRequest_DownloadType_WIN_EXECUTABLE = 0,
+  ClientDownloadRequest_DownloadType_CHROME_EXTENSION = 1,
+  ClientDownloadRequest_DownloadType_ANDROID_APK = 2,
+  ClientDownloadRequest_DownloadType_ZIPPED_EXECUTABLE = 3,
+  ClientDownloadRequest_DownloadType_MAC_EXECUTABLE = 4,
+  ClientDownloadRequest_DownloadType_ZIPPED_ARCHIVE = 5,
+  ClientDownloadRequest_DownloadType_ARCHIVE = 6,
+  ClientDownloadRequest_DownloadType_INVALID_ZIP = 7,
+  ClientDownloadRequest_DownloadType_INVALID_MAC_ARCHIVE = 8,
+  ClientDownloadRequest_DownloadType_PPAPI_SAVE_REQUEST = 9,
+  ClientDownloadRequest_DownloadType_SAMPLED_UNSUPPORTED_FILE = 10
+};
+bool ClientDownloadRequest_DownloadType_IsValid(int value);
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest_DownloadType_DownloadType_MIN = ClientDownloadRequest_DownloadType_WIN_EXECUTABLE;
+constexpr ClientDownloadRequest_DownloadType ClientDownloadRequest_DownloadType_DownloadType_MAX = ClientDownloadRequest_DownloadType_SAMPLED_UNSUPPORTED_FILE;
+constexpr int ClientDownloadRequest_DownloadType_DownloadType_ARRAYSIZE = ClientDownloadRequest_DownloadType_DownloadType_MAX + 1;
+
+const std::string& ClientDownloadRequest_DownloadType_Name(ClientDownloadRequest_DownloadType value);
+template<typename T>
+inline const std::string& ClientDownloadRequest_DownloadType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientDownloadRequest_DownloadType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientDownloadRequest_DownloadType_Name.");
+  return ClientDownloadRequest_DownloadType_Name(static_cast<ClientDownloadRequest_DownloadType>(enum_t_value));
+}
+bool ClientDownloadRequest_DownloadType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientDownloadRequest_DownloadType* value);
+enum ReferrerChainEntry_URLType : int {
+  ReferrerChainEntry_URLType_EVENT_URL = 1,
+  ReferrerChainEntry_URLType_LANDING_PAGE = 2,
+  ReferrerChainEntry_URLType_LANDING_REFERRER = 3,
+  ReferrerChainEntry_URLType_CLIENT_REDIRECT = 4,
+  ReferrerChainEntry_URLType_DEPRECATED_SERVER_REDIRECT = 5
+};
+bool ReferrerChainEntry_URLType_IsValid(int value);
+constexpr ReferrerChainEntry_URLType ReferrerChainEntry_URLType_URLType_MIN = ReferrerChainEntry_URLType_EVENT_URL;
+constexpr ReferrerChainEntry_URLType ReferrerChainEntry_URLType_URLType_MAX = ReferrerChainEntry_URLType_DEPRECATED_SERVER_REDIRECT;
+constexpr int ReferrerChainEntry_URLType_URLType_ARRAYSIZE = ReferrerChainEntry_URLType_URLType_MAX + 1;
+
+const std::string& ReferrerChainEntry_URLType_Name(ReferrerChainEntry_URLType value);
+template<typename T>
+inline const std::string& ReferrerChainEntry_URLType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ReferrerChainEntry_URLType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ReferrerChainEntry_URLType_Name.");
+  return ReferrerChainEntry_URLType_Name(static_cast<ReferrerChainEntry_URLType>(enum_t_value));
+}
+bool ReferrerChainEntry_URLType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReferrerChainEntry_URLType* value);
+enum ClientDownloadResponse_Verdict : int {
+  ClientDownloadResponse_Verdict_SAFE = 0,
+  ClientDownloadResponse_Verdict_DANGEROUS = 1,
+  ClientDownloadResponse_Verdict_UNCOMMON = 2,
+  ClientDownloadResponse_Verdict_POTENTIALLY_UNWANTED = 3,
+  ClientDownloadResponse_Verdict_DANGEROUS_HOST = 4,
+  ClientDownloadResponse_Verdict_UNKNOWN = 5
+};
+bool ClientDownloadResponse_Verdict_IsValid(int value);
+constexpr ClientDownloadResponse_Verdict ClientDownloadResponse_Verdict_Verdict_MIN = ClientDownloadResponse_Verdict_SAFE;
+constexpr ClientDownloadResponse_Verdict ClientDownloadResponse_Verdict_Verdict_MAX = ClientDownloadResponse_Verdict_UNKNOWN;
+constexpr int ClientDownloadResponse_Verdict_Verdict_ARRAYSIZE = ClientDownloadResponse_Verdict_Verdict_MAX + 1;
+
+const std::string& ClientDownloadResponse_Verdict_Name(ClientDownloadResponse_Verdict value);
+template<typename T>
+inline const std::string& ClientDownloadResponse_Verdict_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientDownloadResponse_Verdict>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientDownloadResponse_Verdict_Name.");
+  return ClientDownloadResponse_Verdict_Name(static_cast<ClientDownloadResponse_Verdict>(enum_t_value));
+}
+bool ClientDownloadResponse_Verdict_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientDownloadResponse_Verdict* value);
+enum ClientDownloadReport_Reason : int {
+  ClientDownloadReport_Reason_SHARE = 0,
+  ClientDownloadReport_Reason_FALSE_POSITIVE = 1,
+  ClientDownloadReport_Reason_APPEAL = 2
+};
+bool ClientDownloadReport_Reason_IsValid(int value);
+constexpr ClientDownloadReport_Reason ClientDownloadReport_Reason_Reason_MIN = ClientDownloadReport_Reason_SHARE;
+constexpr ClientDownloadReport_Reason ClientDownloadReport_Reason_Reason_MAX = ClientDownloadReport_Reason_APPEAL;
+constexpr int ClientDownloadReport_Reason_Reason_ARRAYSIZE = ClientDownloadReport_Reason_Reason_MAX + 1;
+
+const std::string& ClientDownloadReport_Reason_Name(ClientDownloadReport_Reason value);
+template<typename T>
+inline const std::string& ClientDownloadReport_Reason_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientDownloadReport_Reason>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientDownloadReport_Reason_Name.");
+  return ClientDownloadReport_Reason_Name(static_cast<ClientDownloadReport_Reason>(enum_t_value));
+}
+bool ClientDownloadReport_Reason_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientDownloadReport_Reason* value);
+enum ClientUploadResponse_UploadStatus : int {
+  ClientUploadResponse_UploadStatus_SUCCESS = 0,
+  ClientUploadResponse_UploadStatus_UPLOAD_FAILURE = 1
+};
+bool ClientUploadResponse_UploadStatus_IsValid(int value);
+constexpr ClientUploadResponse_UploadStatus ClientUploadResponse_UploadStatus_UploadStatus_MIN = ClientUploadResponse_UploadStatus_SUCCESS;
+constexpr ClientUploadResponse_UploadStatus ClientUploadResponse_UploadStatus_UploadStatus_MAX = ClientUploadResponse_UploadStatus_UPLOAD_FAILURE;
+constexpr int ClientUploadResponse_UploadStatus_UploadStatus_ARRAYSIZE = ClientUploadResponse_UploadStatus_UploadStatus_MAX + 1;
+
+const std::string& ClientUploadResponse_UploadStatus_Name(ClientUploadResponse_UploadStatus value);
+template<typename T>
+inline const std::string& ClientUploadResponse_UploadStatus_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientUploadResponse_UploadStatus>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientUploadResponse_UploadStatus_Name.");
+  return ClientUploadResponse_UploadStatus_Name(static_cast<ClientUploadResponse_UploadStatus>(enum_t_value));
+}
+bool ClientUploadResponse_UploadStatus_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientUploadResponse_UploadStatus* value);
+enum ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState : int {
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_UNKNOWN = 0,
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_CLEARED = 1,
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_WEAK_LEGACY_OBSOLETE = 2,
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_CHANGED = 3,
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_UNTRUSTED_UNKNOWN_VALUE = 4,
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_BYPASS_CLEARED = 5,
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_BYPASS_CHANGED = 6
+};
+bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_IsValid(int value);
+constexpr ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_MIN = ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_UNKNOWN;
+constexpr ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_MAX = ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_BYPASS_CHANGED;
+constexpr int ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_ARRAYSIZE = ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_MAX + 1;
+
+const std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_Name(ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState value);
+template<typename T>
+inline const std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_Name.");
+  return ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_Name(static_cast<ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState>(enum_t_value));
+}
+bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState* value);
+enum ClientIncidentReport_IncidentData_ResourceRequestIncident_Type : int {
+  ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_UNKNOWN = 0,
+  ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_TYPE_PATTERN = 3
+};
+bool ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_IsValid(int value);
+constexpr ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_MIN = ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_UNKNOWN;
+constexpr ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_MAX = ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_TYPE_PATTERN;
+constexpr int ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_ARRAYSIZE = ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_MAX + 1;
+
+const std::string& ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Name(ClientIncidentReport_IncidentData_ResourceRequestIncident_Type value);
+template<typename T>
+inline const std::string& ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIncidentReport_IncidentData_ResourceRequestIncident_Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Name.");
+  return ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Name(static_cast<ClientIncidentReport_IncidentData_ResourceRequestIncident_Type>(enum_t_value));
+}
+bool ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIncidentReport_IncidentData_ResourceRequestIncident_Type* value);
+enum ClientIncidentReport_EnvironmentData_Process_Dll_Feature : int {
+  ClientIncidentReport_EnvironmentData_Process_Dll_Feature_UNKNOWN = 0,
+  ClientIncidentReport_EnvironmentData_Process_Dll_Feature_LSP = 1
+};
+bool ClientIncidentReport_EnvironmentData_Process_Dll_Feature_IsValid(int value);
+constexpr ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_MIN = ClientIncidentReport_EnvironmentData_Process_Dll_Feature_UNKNOWN;
+constexpr ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_MAX = ClientIncidentReport_EnvironmentData_Process_Dll_Feature_LSP;
+constexpr int ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_ARRAYSIZE = ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_MAX + 1;
+
+const std::string& ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Name(ClientIncidentReport_EnvironmentData_Process_Dll_Feature value);
+template<typename T>
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIncidentReport_EnvironmentData_Process_Dll_Feature>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Name.");
+  return ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Name(static_cast<ClientIncidentReport_EnvironmentData_Process_Dll_Feature>(enum_t_value));
+}
+bool ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIncidentReport_EnvironmentData_Process_Dll_Feature* value);
+enum ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState : int {
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_UNKNOWN = 0,
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_MODULE_STATE_UNKNOWN = 1,
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_MODULE_STATE_UNMODIFIED = 2,
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_MODULE_STATE_MODIFIED = 3
+};
+bool ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_IsValid(int value);
+constexpr ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_MIN = ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_UNKNOWN;
+constexpr ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_MAX = ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_MODULE_STATE_MODIFIED;
+constexpr int ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_ARRAYSIZE = ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_MAX + 1;
+
+const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_Name(ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState value);
+template<typename T>
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_Name.");
+  return ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_Name(static_cast<ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState>(enum_t_value));
+}
+bool ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState* value);
+enum ClientIncidentReport_EnvironmentData_Process_Channel : int {
+  ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_UNKNOWN = 0,
+  ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_CANARY = 1,
+  ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_DEV = 2,
+  ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_BETA = 3,
+  ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_STABLE = 4
+};
+bool ClientIncidentReport_EnvironmentData_Process_Channel_IsValid(int value);
+constexpr ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process_Channel_Channel_MIN = ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_UNKNOWN;
+constexpr ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process_Channel_Channel_MAX = ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_STABLE;
+constexpr int ClientIncidentReport_EnvironmentData_Process_Channel_Channel_ARRAYSIZE = ClientIncidentReport_EnvironmentData_Process_Channel_Channel_MAX + 1;
+
+const std::string& ClientIncidentReport_EnvironmentData_Process_Channel_Name(ClientIncidentReport_EnvironmentData_Process_Channel value);
+template<typename T>
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_Channel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIncidentReport_EnvironmentData_Process_Channel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIncidentReport_EnvironmentData_Process_Channel_Name.");
+  return ClientIncidentReport_EnvironmentData_Process_Channel_Name(static_cast<ClientIncidentReport_EnvironmentData_Process_Channel>(enum_t_value));
+}
+bool ClientIncidentReport_EnvironmentData_Process_Channel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIncidentReport_EnvironmentData_Process_Channel* value);
+enum ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState : int {
+  ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_UNKNOWN = 0,
+  ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_ENABLED = 1,
+  ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_DISABLED = 2,
+  ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_BLACKLISTED = 3,
+  ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_BLOCKED = 4,
+  ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_TERMINATED = 5
+};
+bool ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_IsValid(int value);
+constexpr ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_MIN = ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_UNKNOWN;
+constexpr ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_MAX = ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_TERMINATED;
+constexpr int ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_ARRAYSIZE = ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_MAX + 1;
+
+const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_Name(ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState value);
+template<typename T>
+inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_Name.");
+  return ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_Name(static_cast<ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState>(enum_t_value));
+}
+bool ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState* value);
+enum ClientSafeBrowsingReportRequest_ReportType : int {
+  ClientSafeBrowsingReportRequest_ReportType_UNKNOWN = 0,
+  ClientSafeBrowsingReportRequest_ReportType_URL_PHISHING = 1,
+  ClientSafeBrowsingReportRequest_ReportType_URL_MALWARE = 2,
+  ClientSafeBrowsingReportRequest_ReportType_URL_UNWANTED = 3,
+  ClientSafeBrowsingReportRequest_ReportType_URL_CLIENT_SIDE_PHISHING = 4,
+  ClientSafeBrowsingReportRequest_ReportType_URL_CLIENT_SIDE_MALWARE = 5,
+  ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_RECOVERY = 6,
+  ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_WARNING = 7,
+  ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_BY_API = 10,
+  ClientSafeBrowsingReportRequest_ReportType_URL_PASSWORD_PROTECTION_PHISHING = 12,
+  ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_OPENED = 13,
+  ClientSafeBrowsingReportRequest_ReportType_AD_SAMPLE = 14
+};
+bool ClientSafeBrowsingReportRequest_ReportType_IsValid(int value);
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest_ReportType_ReportType_MIN = ClientSafeBrowsingReportRequest_ReportType_UNKNOWN;
+constexpr ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest_ReportType_ReportType_MAX = ClientSafeBrowsingReportRequest_ReportType_AD_SAMPLE;
+constexpr int ClientSafeBrowsingReportRequest_ReportType_ReportType_ARRAYSIZE = ClientSafeBrowsingReportRequest_ReportType_ReportType_MAX + 1;
+
+const std::string& ClientSafeBrowsingReportRequest_ReportType_Name(ClientSafeBrowsingReportRequest_ReportType value);
+template<typename T>
+inline const std::string& ClientSafeBrowsingReportRequest_ReportType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientSafeBrowsingReportRequest_ReportType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientSafeBrowsingReportRequest_ReportType_Name.");
+  return ClientSafeBrowsingReportRequest_ReportType_Name(static_cast<ClientSafeBrowsingReportRequest_ReportType>(enum_t_value));
+}
+bool ClientSafeBrowsingReportRequest_ReportType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientSafeBrowsingReportRequest_ReportType* value);
+enum ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType : int {
+  ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_SAFE_BROWSING_URL_API_TYPE_UNSPECIFIED = 0,
+  ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_PVER3_NATIVE = 1,
+  ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_PVER4_NATIVE = 2,
+  ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_ANDROID_SAFETYNET = 3,
+  ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_FLYWHEEL = 4
+};
+bool ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_IsValid(int value);
+constexpr ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_SafeBrowsingUrlApiType_MIN = ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_SAFE_BROWSING_URL_API_TYPE_UNSPECIFIED;
+constexpr ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_SafeBrowsingUrlApiType_MAX = ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_FLYWHEEL;
+constexpr int ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_SafeBrowsingUrlApiType_ARRAYSIZE = ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_SafeBrowsingUrlApiType_MAX + 1;
+
+const std::string& ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_Name(ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType value);
+template<typename T>
+inline const std::string& ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_Name.");
+  return ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_Name(static_cast<ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType>(enum_t_value));
+}
+bool ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType* value);
+// ===================================================================
+
+class ChromeUserPopulation final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ChromeUserPopulation) */ {
+ public:
+  inline ChromeUserPopulation() : ChromeUserPopulation(nullptr) {}
+  ~ChromeUserPopulation() override;
+  explicit PROTOBUF_CONSTEXPR ChromeUserPopulation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ChromeUserPopulation(const ChromeUserPopulation& from);
+  ChromeUserPopulation(ChromeUserPopulation&& from) noexcept
+    : ChromeUserPopulation() {
+    *this = ::std::move(from);
+  }
+
+  inline ChromeUserPopulation& operator=(const ChromeUserPopulation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ChromeUserPopulation& operator=(ChromeUserPopulation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ChromeUserPopulation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ChromeUserPopulation* internal_default_instance() {
+    return reinterpret_cast<const ChromeUserPopulation*>(
+               &_ChromeUserPopulation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ChromeUserPopulation& a, ChromeUserPopulation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ChromeUserPopulation* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ChromeUserPopulation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ChromeUserPopulation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ChromeUserPopulation>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ChromeUserPopulation& from);
+  void MergeFrom(const ChromeUserPopulation& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ChromeUserPopulation* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ChromeUserPopulation";
+  }
+  protected:
+  explicit ChromeUserPopulation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ChromeUserPopulation_UserPopulation UserPopulation;
+  static constexpr UserPopulation UNKNOWN_USER_POPULATION =
+    ChromeUserPopulation_UserPopulation_UNKNOWN_USER_POPULATION;
+  static constexpr UserPopulation SAFE_BROWSING =
+    ChromeUserPopulation_UserPopulation_SAFE_BROWSING;
+  static constexpr UserPopulation EXTENDED_REPORTING =
+    ChromeUserPopulation_UserPopulation_EXTENDED_REPORTING;
+  static inline bool UserPopulation_IsValid(int value) {
+    return ChromeUserPopulation_UserPopulation_IsValid(value);
+  }
+  static constexpr UserPopulation UserPopulation_MIN =
+    ChromeUserPopulation_UserPopulation_UserPopulation_MIN;
+  static constexpr UserPopulation UserPopulation_MAX =
+    ChromeUserPopulation_UserPopulation_UserPopulation_MAX;
+  static constexpr int UserPopulation_ARRAYSIZE =
+    ChromeUserPopulation_UserPopulation_UserPopulation_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& UserPopulation_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, UserPopulation>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function UserPopulation_Name.");
+    return ChromeUserPopulation_UserPopulation_Name(enum_t_value);
+  }
+  static inline bool UserPopulation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      UserPopulation* value) {
+    return ChromeUserPopulation_UserPopulation_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFinchActiveGroupsFieldNumber = 4,
+    kUserPopulationFieldNumber = 1,
+    kIsHistorySyncEnabledFieldNumber = 2,
+  };
+  // repeated string finch_active_groups = 4;
+  int finch_active_groups_size() const;
+  private:
+  int _internal_finch_active_groups_size() const;
+  public:
+  void clear_finch_active_groups();
+  const std::string& finch_active_groups(int index) const;
+  std::string* mutable_finch_active_groups(int index);
+  void set_finch_active_groups(int index, const std::string& value);
+  void set_finch_active_groups(int index, std::string&& value);
+  void set_finch_active_groups(int index, const char* value);
+  void set_finch_active_groups(int index, const char* value, size_t size);
+  std::string* add_finch_active_groups();
+  void add_finch_active_groups(const std::string& value);
+  void add_finch_active_groups(std::string&& value);
+  void add_finch_active_groups(const char* value);
+  void add_finch_active_groups(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& finch_active_groups() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_finch_active_groups();
+  private:
+  const std::string& _internal_finch_active_groups(int index) const;
+  std::string* _internal_add_finch_active_groups();
+  public:
+
+  // optional .safe_browsing.ChromeUserPopulation.UserPopulation user_population = 1;
+  bool has_user_population() const;
+  private:
+  bool _internal_has_user_population() const;
+  public:
+  void clear_user_population();
+  ::safe_browsing::ChromeUserPopulation_UserPopulation user_population() const;
+  void set_user_population(::safe_browsing::ChromeUserPopulation_UserPopulation value);
+  private:
+  ::safe_browsing::ChromeUserPopulation_UserPopulation _internal_user_population() const;
+  void _internal_set_user_population(::safe_browsing::ChromeUserPopulation_UserPopulation value);
+  public:
+
+  // optional bool is_history_sync_enabled = 2;
+  bool has_is_history_sync_enabled() const;
+  private:
+  bool _internal_has_is_history_sync_enabled() const;
+  public:
+  void clear_is_history_sync_enabled();
+  bool is_history_sync_enabled() const;
+  void set_is_history_sync_enabled(bool value);
+  private:
+  bool _internal_is_history_sync_enabled() const;
+  void _internal_set_is_history_sync_enabled(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ChromeUserPopulation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> finch_active_groups_;
+    int user_population_;
+    bool is_history_sync_enabled_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientPhishingRequest_Feature final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientPhishingRequest.Feature) */ {
+ public:
+  inline ClientPhishingRequest_Feature() : ClientPhishingRequest_Feature(nullptr) {}
+  ~ClientPhishingRequest_Feature() override;
+  explicit PROTOBUF_CONSTEXPR ClientPhishingRequest_Feature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientPhishingRequest_Feature(const ClientPhishingRequest_Feature& from);
+  ClientPhishingRequest_Feature(ClientPhishingRequest_Feature&& from) noexcept
+    : ClientPhishingRequest_Feature() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientPhishingRequest_Feature& operator=(const ClientPhishingRequest_Feature& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientPhishingRequest_Feature& operator=(ClientPhishingRequest_Feature&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientPhishingRequest_Feature& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientPhishingRequest_Feature* internal_default_instance() {
+    return reinterpret_cast<const ClientPhishingRequest_Feature*>(
+               &_ClientPhishingRequest_Feature_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ClientPhishingRequest_Feature& a, ClientPhishingRequest_Feature& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientPhishingRequest_Feature* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientPhishingRequest_Feature* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientPhishingRequest_Feature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientPhishingRequest_Feature>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientPhishingRequest_Feature& from);
+  void MergeFrom(const ClientPhishingRequest_Feature& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientPhishingRequest_Feature* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientPhishingRequest.Feature";
+  }
+  protected:
+  explicit ClientPhishingRequest_Feature(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  // required string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // required double value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  double value() const;
+  void set_value(double value);
+  private:
+  double _internal_value() const;
+  void _internal_set_value(double value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientPhishingRequest.Feature)
+ private:
+  class _Internal;
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    double value_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientPhishingRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientPhishingRequest) */ {
+ public:
+  inline ClientPhishingRequest() : ClientPhishingRequest(nullptr) {}
+  ~ClientPhishingRequest() override;
+  explicit PROTOBUF_CONSTEXPR ClientPhishingRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientPhishingRequest(const ClientPhishingRequest& from);
+  ClientPhishingRequest(ClientPhishingRequest&& from) noexcept
+    : ClientPhishingRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientPhishingRequest& operator=(const ClientPhishingRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientPhishingRequest& operator=(ClientPhishingRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientPhishingRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientPhishingRequest* internal_default_instance() {
+    return reinterpret_cast<const ClientPhishingRequest*>(
+               &_ClientPhishingRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(ClientPhishingRequest& a, ClientPhishingRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientPhishingRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientPhishingRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientPhishingRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientPhishingRequest>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientPhishingRequest& from);
+  void MergeFrom(const ClientPhishingRequest& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientPhishingRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientPhishingRequest";
+  }
+  protected:
+  explicit ClientPhishingRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientPhishingRequest_Feature Feature;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFeatureMapFieldNumber = 5,
+    kNonModelFeatureMapFieldNumber = 8,
+    kShingleHashesFieldNumber = 12,
+    kUrlFieldNumber = 1,
+    kOBSOLETEReferrerUrlFieldNumber = 9,
+    kOBSOLETEHashPrefixFieldNumber = 10,
+    kModelFilenameFieldNumber = 13,
+    kPopulationFieldNumber = 14,
+    kClientScoreFieldNumber = 2,
+    kIsPhishingFieldNumber = 4,
+    kModelVersionFieldNumber = 6,
+  };
+  // repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5;
+  int feature_map_size() const;
+  private:
+  int _internal_feature_map_size() const;
+  public:
+  void clear_feature_map();
+  ::safe_browsing::ClientPhishingRequest_Feature* mutable_feature_map(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >*
+      mutable_feature_map();
+  private:
+  const ::safe_browsing::ClientPhishingRequest_Feature& _internal_feature_map(int index) const;
+  ::safe_browsing::ClientPhishingRequest_Feature* _internal_add_feature_map();
+  public:
+  const ::safe_browsing::ClientPhishingRequest_Feature& feature_map(int index) const;
+  ::safe_browsing::ClientPhishingRequest_Feature* add_feature_map();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >&
+      feature_map() const;
+
+  // repeated .safe_browsing.ClientPhishingRequest.Feature non_model_feature_map = 8;
+  int non_model_feature_map_size() const;
+  private:
+  int _internal_non_model_feature_map_size() const;
+  public:
+  void clear_non_model_feature_map();
+  ::safe_browsing::ClientPhishingRequest_Feature* mutable_non_model_feature_map(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >*
+      mutable_non_model_feature_map();
+  private:
+  const ::safe_browsing::ClientPhishingRequest_Feature& _internal_non_model_feature_map(int index) const;
+  ::safe_browsing::ClientPhishingRequest_Feature* _internal_add_non_model_feature_map();
+  public:
+  const ::safe_browsing::ClientPhishingRequest_Feature& non_model_feature_map(int index) const;
+  ::safe_browsing::ClientPhishingRequest_Feature* add_non_model_feature_map();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >&
+      non_model_feature_map() const;
+
+  // repeated uint32 shingle_hashes = 12 [packed = true];
+  int shingle_hashes_size() const;
+  private:
+  int _internal_shingle_hashes_size() const;
+  public:
+  void clear_shingle_hashes();
+  private:
+  uint32_t _internal_shingle_hashes(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      _internal_shingle_hashes() const;
+  void _internal_add_shingle_hashes(uint32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      _internal_mutable_shingle_hashes();
+  public:
+  uint32_t shingle_hashes(int index) const;
+  void set_shingle_hashes(int index, uint32_t value);
+  void add_shingle_hashes(uint32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+      shingle_hashes() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+      mutable_shingle_hashes();
+
+  // optional string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string OBSOLETE_referrer_url = 9;
+  bool has_obsolete_referrer_url() const;
+  private:
+  bool _internal_has_obsolete_referrer_url() const;
+  public:
+  void clear_obsolete_referrer_url();
+  const std::string& obsolete_referrer_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_obsolete_referrer_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_obsolete_referrer_url();
+  PROTOBUF_NODISCARD std::string* release_obsolete_referrer_url();
+  void set_allocated_obsolete_referrer_url(std::string* obsolete_referrer_url);
+  private:
+  const std::string& _internal_obsolete_referrer_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_obsolete_referrer_url(const std::string& value);
+  std::string* _internal_mutable_obsolete_referrer_url();
+  public:
+
+  // optional bytes OBSOLETE_hash_prefix = 10;
+  bool has_obsolete_hash_prefix() const;
+  private:
+  bool _internal_has_obsolete_hash_prefix() const;
+  public:
+  void clear_obsolete_hash_prefix();
+  const std::string& obsolete_hash_prefix() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_obsolete_hash_prefix(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_obsolete_hash_prefix();
+  PROTOBUF_NODISCARD std::string* release_obsolete_hash_prefix();
+  void set_allocated_obsolete_hash_prefix(std::string* obsolete_hash_prefix);
+  private:
+  const std::string& _internal_obsolete_hash_prefix() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_obsolete_hash_prefix(const std::string& value);
+  std::string* _internal_mutable_obsolete_hash_prefix();
+  public:
+
+  // optional string model_filename = 13;
+  bool has_model_filename() const;
+  private:
+  bool _internal_has_model_filename() const;
+  public:
+  void clear_model_filename();
+  const std::string& model_filename() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_model_filename(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_model_filename();
+  PROTOBUF_NODISCARD std::string* release_model_filename();
+  void set_allocated_model_filename(std::string* model_filename);
+  private:
+  const std::string& _internal_model_filename() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model_filename(const std::string& value);
+  std::string* _internal_mutable_model_filename();
+  public:
+
+  // optional .safe_browsing.ChromeUserPopulation population = 14;
+  bool has_population() const;
+  private:
+  bool _internal_has_population() const;
+  public:
+  void clear_population();
+  const ::safe_browsing::ChromeUserPopulation& population() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ChromeUserPopulation* release_population();
+  ::safe_browsing::ChromeUserPopulation* mutable_population();
+  void set_allocated_population(::safe_browsing::ChromeUserPopulation* population);
+  private:
+  const ::safe_browsing::ChromeUserPopulation& _internal_population() const;
+  ::safe_browsing::ChromeUserPopulation* _internal_mutable_population();
+  public:
+  void unsafe_arena_set_allocated_population(
+      ::safe_browsing::ChromeUserPopulation* population);
+  ::safe_browsing::ChromeUserPopulation* unsafe_arena_release_population();
+
+  // required float client_score = 2;
+  bool has_client_score() const;
+  private:
+  bool _internal_has_client_score() const;
+  public:
+  void clear_client_score();
+  float client_score() const;
+  void set_client_score(float value);
+  private:
+  float _internal_client_score() const;
+  void _internal_set_client_score(float value);
+  public:
+
+  // optional bool is_phishing = 4;
+  bool has_is_phishing() const;
+  private:
+  bool _internal_has_is_phishing() const;
+  public:
+  void clear_is_phishing();
+  bool is_phishing() const;
+  void set_is_phishing(bool value);
+  private:
+  bool _internal_is_phishing() const;
+  void _internal_set_is_phishing(bool value);
+  public:
+
+  // optional int32 model_version = 6;
+  bool has_model_version() const;
+  private:
+  bool _internal_has_model_version() const;
+  public:
+  void clear_model_version();
+  int32_t model_version() const;
+  void set_model_version(int32_t value);
+  private:
+  int32_t _internal_model_version() const;
+  void _internal_set_model_version(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientPhishingRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature > feature_map_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature > non_model_feature_map_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > shingle_hashes_;
+    mutable std::atomic<int> _shingle_hashes_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr obsolete_referrer_url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr obsolete_hash_prefix_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_filename_;
+    ::safe_browsing::ChromeUserPopulation* population_;
+    float client_score_;
+    bool is_phishing_;
+    int32_t model_version_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientPhishingResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientPhishingResponse) */ {
+ public:
+  inline ClientPhishingResponse() : ClientPhishingResponse(nullptr) {}
+  ~ClientPhishingResponse() override;
+  explicit PROTOBUF_CONSTEXPR ClientPhishingResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientPhishingResponse(const ClientPhishingResponse& from);
+  ClientPhishingResponse(ClientPhishingResponse&& from) noexcept
+    : ClientPhishingResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientPhishingResponse& operator=(const ClientPhishingResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientPhishingResponse& operator=(ClientPhishingResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientPhishingResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientPhishingResponse* internal_default_instance() {
+    return reinterpret_cast<const ClientPhishingResponse*>(
+               &_ClientPhishingResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(ClientPhishingResponse& a, ClientPhishingResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientPhishingResponse* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientPhishingResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientPhishingResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientPhishingResponse>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientPhishingResponse& from);
+  void MergeFrom(const ClientPhishingResponse& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientPhishingResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientPhishingResponse";
+  }
+  protected:
+  explicit ClientPhishingResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOBSOLETEWhitelistExpressionFieldNumber = 2,
+    kPhishyFieldNumber = 1,
+  };
+  // repeated string OBSOLETE_whitelist_expression = 2;
+  int obsolete_whitelist_expression_size() const;
+  private:
+  int _internal_obsolete_whitelist_expression_size() const;
+  public:
+  void clear_obsolete_whitelist_expression();
+  const std::string& obsolete_whitelist_expression(int index) const;
+  std::string* mutable_obsolete_whitelist_expression(int index);
+  void set_obsolete_whitelist_expression(int index, const std::string& value);
+  void set_obsolete_whitelist_expression(int index, std::string&& value);
+  void set_obsolete_whitelist_expression(int index, const char* value);
+  void set_obsolete_whitelist_expression(int index, const char* value, size_t size);
+  std::string* add_obsolete_whitelist_expression();
+  void add_obsolete_whitelist_expression(const std::string& value);
+  void add_obsolete_whitelist_expression(std::string&& value);
+  void add_obsolete_whitelist_expression(const char* value);
+  void add_obsolete_whitelist_expression(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& obsolete_whitelist_expression() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_obsolete_whitelist_expression();
+  private:
+  const std::string& _internal_obsolete_whitelist_expression(int index) const;
+  std::string* _internal_add_obsolete_whitelist_expression();
+  public:
+
+  // required bool phishy = 1;
+  bool has_phishy() const;
+  private:
+  bool _internal_has_phishy() const;
+  public:
+  void clear_phishy();
+  bool phishy() const;
+  void set_phishy(bool value);
+  private:
+  bool _internal_phishy() const;
+  void _internal_set_phishy(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientPhishingResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> obsolete_whitelist_expression_;
+    bool phishy_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientMalwareRequest_UrlInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientMalwareRequest.UrlInfo) */ {
+ public:
+  inline ClientMalwareRequest_UrlInfo() : ClientMalwareRequest_UrlInfo(nullptr) {}
+  ~ClientMalwareRequest_UrlInfo() override;
+  explicit PROTOBUF_CONSTEXPR ClientMalwareRequest_UrlInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientMalwareRequest_UrlInfo(const ClientMalwareRequest_UrlInfo& from);
+  ClientMalwareRequest_UrlInfo(ClientMalwareRequest_UrlInfo&& from) noexcept
+    : ClientMalwareRequest_UrlInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientMalwareRequest_UrlInfo& operator=(const ClientMalwareRequest_UrlInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientMalwareRequest_UrlInfo& operator=(ClientMalwareRequest_UrlInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientMalwareRequest_UrlInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientMalwareRequest_UrlInfo* internal_default_instance() {
+    return reinterpret_cast<const ClientMalwareRequest_UrlInfo*>(
+               &_ClientMalwareRequest_UrlInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ClientMalwareRequest_UrlInfo& a, ClientMalwareRequest_UrlInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientMalwareRequest_UrlInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientMalwareRequest_UrlInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientMalwareRequest_UrlInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientMalwareRequest_UrlInfo>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientMalwareRequest_UrlInfo& from);
+  void MergeFrom(const ClientMalwareRequest_UrlInfo& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientMalwareRequest_UrlInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientMalwareRequest.UrlInfo";
+  }
+  protected:
+  explicit ClientMalwareRequest_UrlInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIpFieldNumber = 1,
+    kUrlFieldNumber = 2,
+    kMethodFieldNumber = 3,
+    kReferrerFieldNumber = 4,
+    kResourceTypeFieldNumber = 5,
+  };
+  // required string ip = 1;
+  bool has_ip() const;
+  private:
+  bool _internal_has_ip() const;
+  public:
+  void clear_ip();
+  const std::string& ip() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_ip(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_ip();
+  PROTOBUF_NODISCARD std::string* release_ip();
+  void set_allocated_ip(std::string* ip);
+  private:
+  const std::string& _internal_ip() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ip(const std::string& value);
+  std::string* _internal_mutable_ip();
+  public:
+
+  // required string url = 2;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string method = 3;
+  bool has_method() const;
+  private:
+  bool _internal_has_method() const;
+  public:
+  void clear_method();
+  const std::string& method() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_method(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_method();
+  PROTOBUF_NODISCARD std::string* release_method();
+  void set_allocated_method(std::string* method);
+  private:
+  const std::string& _internal_method() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_method(const std::string& value);
+  std::string* _internal_mutable_method();
+  public:
+
+  // optional string referrer = 4;
+  bool has_referrer() const;
+  private:
+  bool _internal_has_referrer() const;
+  public:
+  void clear_referrer();
+  const std::string& referrer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_referrer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_referrer();
+  PROTOBUF_NODISCARD std::string* release_referrer();
+  void set_allocated_referrer(std::string* referrer);
+  private:
+  const std::string& _internal_referrer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_referrer(const std::string& value);
+  std::string* _internal_mutable_referrer();
+  public:
+
+  // optional int32 resource_type = 5;
+  bool has_resource_type() const;
+  private:
+  bool _internal_has_resource_type() const;
+  public:
+  void clear_resource_type();
+  int32_t resource_type() const;
+  void set_resource_type(int32_t value);
+  private:
+  int32_t _internal_resource_type() const;
+  void _internal_set_resource_type(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientMalwareRequest.UrlInfo)
+ private:
+  class _Internal;
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr method_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr referrer_;
+    int32_t resource_type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientMalwareRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientMalwareRequest) */ {
+ public:
+  inline ClientMalwareRequest() : ClientMalwareRequest(nullptr) {}
+  ~ClientMalwareRequest() override;
+  explicit PROTOBUF_CONSTEXPR ClientMalwareRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientMalwareRequest(const ClientMalwareRequest& from);
+  ClientMalwareRequest(ClientMalwareRequest&& from) noexcept
+    : ClientMalwareRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientMalwareRequest& operator=(const ClientMalwareRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientMalwareRequest& operator=(ClientMalwareRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientMalwareRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientMalwareRequest* internal_default_instance() {
+    return reinterpret_cast<const ClientMalwareRequest*>(
+               &_ClientMalwareRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(ClientMalwareRequest& a, ClientMalwareRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientMalwareRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientMalwareRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientMalwareRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientMalwareRequest>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientMalwareRequest& from);
+  void MergeFrom(const ClientMalwareRequest& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientMalwareRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientMalwareRequest";
+  }
+  protected:
+  explicit ClientMalwareRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientMalwareRequest_UrlInfo UrlInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBadIpUrlInfoFieldNumber = 7,
+    kUrlFieldNumber = 1,
+    kReferrerUrlFieldNumber = 4,
+    kPopulationFieldNumber = 9,
+  };
+  // repeated .safe_browsing.ClientMalwareRequest.UrlInfo bad_ip_url_info = 7;
+  int bad_ip_url_info_size() const;
+  private:
+  int _internal_bad_ip_url_info_size() const;
+  public:
+  void clear_bad_ip_url_info();
+  ::safe_browsing::ClientMalwareRequest_UrlInfo* mutable_bad_ip_url_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_UrlInfo >*
+      mutable_bad_ip_url_info();
+  private:
+  const ::safe_browsing::ClientMalwareRequest_UrlInfo& _internal_bad_ip_url_info(int index) const;
+  ::safe_browsing::ClientMalwareRequest_UrlInfo* _internal_add_bad_ip_url_info();
+  public:
+  const ::safe_browsing::ClientMalwareRequest_UrlInfo& bad_ip_url_info(int index) const;
+  ::safe_browsing::ClientMalwareRequest_UrlInfo* add_bad_ip_url_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_UrlInfo >&
+      bad_ip_url_info() const;
+
+  // required string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string referrer_url = 4;
+  bool has_referrer_url() const;
+  private:
+  bool _internal_has_referrer_url() const;
+  public:
+  void clear_referrer_url();
+  const std::string& referrer_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_referrer_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_referrer_url();
+  PROTOBUF_NODISCARD std::string* release_referrer_url();
+  void set_allocated_referrer_url(std::string* referrer_url);
+  private:
+  const std::string& _internal_referrer_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_referrer_url(const std::string& value);
+  std::string* _internal_mutable_referrer_url();
+  public:
+
+  // optional .safe_browsing.ChromeUserPopulation population = 9;
+  bool has_population() const;
+  private:
+  bool _internal_has_population() const;
+  public:
+  void clear_population();
+  const ::safe_browsing::ChromeUserPopulation& population() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ChromeUserPopulation* release_population();
+  ::safe_browsing::ChromeUserPopulation* mutable_population();
+  void set_allocated_population(::safe_browsing::ChromeUserPopulation* population);
+  private:
+  const ::safe_browsing::ChromeUserPopulation& _internal_population() const;
+  ::safe_browsing::ChromeUserPopulation* _internal_mutable_population();
+  public:
+  void unsafe_arena_set_allocated_population(
+      ::safe_browsing::ChromeUserPopulation* population);
+  ::safe_browsing::ChromeUserPopulation* unsafe_arena_release_population();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientMalwareRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_UrlInfo > bad_ip_url_info_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr referrer_url_;
+    ::safe_browsing::ChromeUserPopulation* population_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LoginReputationClientRequest_Frame_Form final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.LoginReputationClientRequest.Frame.Form) */ {
+ public:
+  inline LoginReputationClientRequest_Frame_Form() : LoginReputationClientRequest_Frame_Form(nullptr) {}
+  ~LoginReputationClientRequest_Frame_Form() override;
+  explicit PROTOBUF_CONSTEXPR LoginReputationClientRequest_Frame_Form(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LoginReputationClientRequest_Frame_Form(const LoginReputationClientRequest_Frame_Form& from);
+  LoginReputationClientRequest_Frame_Form(LoginReputationClientRequest_Frame_Form&& from) noexcept
+    : LoginReputationClientRequest_Frame_Form() {
+    *this = ::std::move(from);
+  }
+
+  inline LoginReputationClientRequest_Frame_Form& operator=(const LoginReputationClientRequest_Frame_Form& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LoginReputationClientRequest_Frame_Form& operator=(LoginReputationClientRequest_Frame_Form&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const LoginReputationClientRequest_Frame_Form& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LoginReputationClientRequest_Frame_Form* internal_default_instance() {
+    return reinterpret_cast<const LoginReputationClientRequest_Frame_Form*>(
+               &_LoginReputationClientRequest_Frame_Form_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(LoginReputationClientRequest_Frame_Form& a, LoginReputationClientRequest_Frame_Form& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LoginReputationClientRequest_Frame_Form* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LoginReputationClientRequest_Frame_Form* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  LoginReputationClientRequest_Frame_Form* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<LoginReputationClientRequest_Frame_Form>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const LoginReputationClientRequest_Frame_Form& from);
+  void MergeFrom(const LoginReputationClientRequest_Frame_Form& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(LoginReputationClientRequest_Frame_Form* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.LoginReputationClientRequest.Frame.Form";
+  }
+  protected:
+  explicit LoginReputationClientRequest_Frame_Form(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kActionUrlFieldNumber = 1,
+    kHasPasswordFieldFieldNumber = 2,
+  };
+  // optional string action_url = 1;
+  bool has_action_url() const;
+  private:
+  bool _internal_has_action_url() const;
+  public:
+  void clear_action_url();
+  const std::string& action_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_action_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_action_url();
+  PROTOBUF_NODISCARD std::string* release_action_url();
+  void set_allocated_action_url(std::string* action_url);
+  private:
+  const std::string& _internal_action_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_action_url(const std::string& value);
+  std::string* _internal_mutable_action_url();
+  public:
+
+  // optional bool has_password_field = 2;
+  bool has_has_password_field() const;
+  private:
+  bool _internal_has_has_password_field() const;
+  public:
+  void clear_has_password_field();
+  bool has_password_field() const;
+  void set_has_password_field(bool value);
+  private:
+  bool _internal_has_password_field() const;
+  void _internal_set_has_password_field(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.LoginReputationClientRequest.Frame.Form)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr action_url_;
+    bool has_password_field_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LoginReputationClientRequest_Frame final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.LoginReputationClientRequest.Frame) */ {
+ public:
+  inline LoginReputationClientRequest_Frame() : LoginReputationClientRequest_Frame(nullptr) {}
+  ~LoginReputationClientRequest_Frame() override;
+  explicit PROTOBUF_CONSTEXPR LoginReputationClientRequest_Frame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LoginReputationClientRequest_Frame(const LoginReputationClientRequest_Frame& from);
+  LoginReputationClientRequest_Frame(LoginReputationClientRequest_Frame&& from) noexcept
+    : LoginReputationClientRequest_Frame() {
+    *this = ::std::move(from);
+  }
+
+  inline LoginReputationClientRequest_Frame& operator=(const LoginReputationClientRequest_Frame& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LoginReputationClientRequest_Frame& operator=(LoginReputationClientRequest_Frame&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const LoginReputationClientRequest_Frame& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LoginReputationClientRequest_Frame* internal_default_instance() {
+    return reinterpret_cast<const LoginReputationClientRequest_Frame*>(
+               &_LoginReputationClientRequest_Frame_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(LoginReputationClientRequest_Frame& a, LoginReputationClientRequest_Frame& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LoginReputationClientRequest_Frame* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LoginReputationClientRequest_Frame* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  LoginReputationClientRequest_Frame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<LoginReputationClientRequest_Frame>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const LoginReputationClientRequest_Frame& from);
+  void MergeFrom(const LoginReputationClientRequest_Frame& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(LoginReputationClientRequest_Frame* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.LoginReputationClientRequest.Frame";
+  }
+  protected:
+  explicit LoginReputationClientRequest_Frame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LoginReputationClientRequest_Frame_Form Form;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kReferrerChainFieldNumber = 5,
+    kFormsFieldNumber = 6,
+    kUrlFieldNumber = 3,
+    kFrameIndexFieldNumber = 1,
+    kParentFrameIndexFieldNumber = 2,
+    kHasPasswordFieldFieldNumber = 4,
+  };
+  // repeated .safe_browsing.ReferrerChainEntry referrer_chain = 5;
+  int referrer_chain_size() const;
+  private:
+  int _internal_referrer_chain_size() const;
+  public:
+  void clear_referrer_chain();
+  ::safe_browsing::ReferrerChainEntry* mutable_referrer_chain(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry >*
+      mutable_referrer_chain();
+  private:
+  const ::safe_browsing::ReferrerChainEntry& _internal_referrer_chain(int index) const;
+  ::safe_browsing::ReferrerChainEntry* _internal_add_referrer_chain();
+  public:
+  const ::safe_browsing::ReferrerChainEntry& referrer_chain(int index) const;
+  ::safe_browsing::ReferrerChainEntry* add_referrer_chain();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry >&
+      referrer_chain() const;
+
+  // repeated .safe_browsing.LoginReputationClientRequest.Frame.Form forms = 6;
+  int forms_size() const;
+  private:
+  int _internal_forms_size() const;
+  public:
+  void clear_forms();
+  ::safe_browsing::LoginReputationClientRequest_Frame_Form* mutable_forms(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::LoginReputationClientRequest_Frame_Form >*
+      mutable_forms();
+  private:
+  const ::safe_browsing::LoginReputationClientRequest_Frame_Form& _internal_forms(int index) const;
+  ::safe_browsing::LoginReputationClientRequest_Frame_Form* _internal_add_forms();
+  public:
+  const ::safe_browsing::LoginReputationClientRequest_Frame_Form& forms(int index) const;
+  ::safe_browsing::LoginReputationClientRequest_Frame_Form* add_forms();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::LoginReputationClientRequest_Frame_Form >&
+      forms() const;
+
+  // optional string url = 3;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional int32 frame_index = 1;
+  bool has_frame_index() const;
+  private:
+  bool _internal_has_frame_index() const;
+  public:
+  void clear_frame_index();
+  int32_t frame_index() const;
+  void set_frame_index(int32_t value);
+  private:
+  int32_t _internal_frame_index() const;
+  void _internal_set_frame_index(int32_t value);
+  public:
+
+  // optional int32 parent_frame_index = 2;
+  bool has_parent_frame_index() const;
+  private:
+  bool _internal_has_parent_frame_index() const;
+  public:
+  void clear_parent_frame_index();
+  int32_t parent_frame_index() const;
+  void set_parent_frame_index(int32_t value);
+  private:
+  int32_t _internal_parent_frame_index() const;
+  void _internal_set_parent_frame_index(int32_t value);
+  public:
+
+  // optional bool has_password_field = 4;
+  bool has_has_password_field() const;
+  private:
+  bool _internal_has_has_password_field() const;
+  public:
+  void clear_has_password_field();
+  bool has_password_field() const;
+  void set_has_password_field(bool value);
+  private:
+  bool _internal_has_password_field() const;
+  void _internal_set_has_password_field(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.LoginReputationClientRequest.Frame)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry > referrer_chain_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::LoginReputationClientRequest_Frame_Form > forms_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    int32_t frame_index_;
+    int32_t parent_frame_index_;
+    bool has_password_field_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LoginReputationClientRequest_PasswordReuseEvent final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent) */ {
+ public:
+  inline LoginReputationClientRequest_PasswordReuseEvent() : LoginReputationClientRequest_PasswordReuseEvent(nullptr) {}
+  ~LoginReputationClientRequest_PasswordReuseEvent() override;
+  explicit PROTOBUF_CONSTEXPR LoginReputationClientRequest_PasswordReuseEvent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LoginReputationClientRequest_PasswordReuseEvent(const LoginReputationClientRequest_PasswordReuseEvent& from);
+  LoginReputationClientRequest_PasswordReuseEvent(LoginReputationClientRequest_PasswordReuseEvent&& from) noexcept
+    : LoginReputationClientRequest_PasswordReuseEvent() {
+    *this = ::std::move(from);
+  }
+
+  inline LoginReputationClientRequest_PasswordReuseEvent& operator=(const LoginReputationClientRequest_PasswordReuseEvent& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LoginReputationClientRequest_PasswordReuseEvent& operator=(LoginReputationClientRequest_PasswordReuseEvent&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const LoginReputationClientRequest_PasswordReuseEvent& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LoginReputationClientRequest_PasswordReuseEvent* internal_default_instance() {
+    return reinterpret_cast<const LoginReputationClientRequest_PasswordReuseEvent*>(
+               &_LoginReputationClientRequest_PasswordReuseEvent_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(LoginReputationClientRequest_PasswordReuseEvent& a, LoginReputationClientRequest_PasswordReuseEvent& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LoginReputationClientRequest_PasswordReuseEvent* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LoginReputationClientRequest_PasswordReuseEvent* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  LoginReputationClientRequest_PasswordReuseEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<LoginReputationClientRequest_PasswordReuseEvent>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const LoginReputationClientRequest_PasswordReuseEvent& from);
+  void MergeFrom(const LoginReputationClientRequest_PasswordReuseEvent& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(LoginReputationClientRequest_PasswordReuseEvent* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.LoginReputationClientRequest.PasswordReuseEvent";
+  }
+  protected:
+  explicit LoginReputationClientRequest_PasswordReuseEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType SyncAccountType;
+  static constexpr SyncAccountType NOT_SIGNED_IN =
+    LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_NOT_SIGNED_IN;
+  static constexpr SyncAccountType GMAIL =
+    LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_GMAIL;
+  static constexpr SyncAccountType GSUITE =
+    LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_GSUITE;
+  static inline bool SyncAccountType_IsValid(int value) {
+    return LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_IsValid(value);
+  }
+  static constexpr SyncAccountType SyncAccountType_MIN =
+    LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_SyncAccountType_MIN;
+  static constexpr SyncAccountType SyncAccountType_MAX =
+    LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_SyncAccountType_MAX;
+  static constexpr int SyncAccountType_ARRAYSIZE =
+    LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_SyncAccountType_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& SyncAccountType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SyncAccountType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SyncAccountType_Name.");
+    return LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_Name(enum_t_value);
+  }
+  static inline bool SyncAccountType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SyncAccountType* value) {
+    return LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDomainsMatchingPasswordFieldNumber = 1,
+    kFrameIdFieldNumber = 2,
+    kIsChromeSigninPasswordFieldNumber = 3,
+    kSyncAccountTypeFieldNumber = 4,
+  };
+  // repeated string domains_matching_password = 1;
+  int domains_matching_password_size() const;
+  private:
+  int _internal_domains_matching_password_size() const;
+  public:
+  void clear_domains_matching_password();
+  const std::string& domains_matching_password(int index) const;
+  std::string* mutable_domains_matching_password(int index);
+  void set_domains_matching_password(int index, const std::string& value);
+  void set_domains_matching_password(int index, std::string&& value);
+  void set_domains_matching_password(int index, const char* value);
+  void set_domains_matching_password(int index, const char* value, size_t size);
+  std::string* add_domains_matching_password();
+  void add_domains_matching_password(const std::string& value);
+  void add_domains_matching_password(std::string&& value);
+  void add_domains_matching_password(const char* value);
+  void add_domains_matching_password(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& domains_matching_password() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_domains_matching_password();
+  private:
+  const std::string& _internal_domains_matching_password(int index) const;
+  std::string* _internal_add_domains_matching_password();
+  public:
+
+  // optional int32 frame_id = 2;
+  bool has_frame_id() const;
+  private:
+  bool _internal_has_frame_id() const;
+  public:
+  void clear_frame_id();
+  int32_t frame_id() const;
+  void set_frame_id(int32_t value);
+  private:
+  int32_t _internal_frame_id() const;
+  void _internal_set_frame_id(int32_t value);
+  public:
+
+  // optional bool is_chrome_signin_password = 3;
+  bool has_is_chrome_signin_password() const;
+  private:
+  bool _internal_has_is_chrome_signin_password() const;
+  public:
+  void clear_is_chrome_signin_password();
+  bool is_chrome_signin_password() const;
+  void set_is_chrome_signin_password(bool value);
+  private:
+  bool _internal_is_chrome_signin_password() const;
+  void _internal_set_is_chrome_signin_password(bool value);
+  public:
+
+  // optional .safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.SyncAccountType sync_account_type = 4;
+  bool has_sync_account_type() const;
+  private:
+  bool _internal_has_sync_account_type() const;
+  public:
+  void clear_sync_account_type();
+  ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType sync_account_type() const;
+  void set_sync_account_type(::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType value);
+  private:
+  ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType _internal_sync_account_type() const;
+  void _internal_set_sync_account_type(::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> domains_matching_password_;
+    int32_t frame_id_;
+    bool is_chrome_signin_password_;
+    int sync_account_type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LoginReputationClientRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.LoginReputationClientRequest) */ {
+ public:
+  inline LoginReputationClientRequest() : LoginReputationClientRequest(nullptr) {}
+  ~LoginReputationClientRequest() override;
+  explicit PROTOBUF_CONSTEXPR LoginReputationClientRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LoginReputationClientRequest(const LoginReputationClientRequest& from);
+  LoginReputationClientRequest(LoginReputationClientRequest&& from) noexcept
+    : LoginReputationClientRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline LoginReputationClientRequest& operator=(const LoginReputationClientRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LoginReputationClientRequest& operator=(LoginReputationClientRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const LoginReputationClientRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LoginReputationClientRequest* internal_default_instance() {
+    return reinterpret_cast<const LoginReputationClientRequest*>(
+               &_LoginReputationClientRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(LoginReputationClientRequest& a, LoginReputationClientRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LoginReputationClientRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LoginReputationClientRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  LoginReputationClientRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<LoginReputationClientRequest>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const LoginReputationClientRequest& from);
+  void MergeFrom(const LoginReputationClientRequest& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(LoginReputationClientRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.LoginReputationClientRequest";
+  }
+  protected:
+  explicit LoginReputationClientRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LoginReputationClientRequest_Frame Frame;
+  typedef LoginReputationClientRequest_PasswordReuseEvent PasswordReuseEvent;
+
+  typedef LoginReputationClientRequest_TriggerType TriggerType;
+  static constexpr TriggerType TRIGGER_TYPE_UNSPECIFIED =
+    LoginReputationClientRequest_TriggerType_TRIGGER_TYPE_UNSPECIFIED;
+  static constexpr TriggerType UNFAMILIAR_LOGIN_PAGE =
+    LoginReputationClientRequest_TriggerType_UNFAMILIAR_LOGIN_PAGE;
+  static constexpr TriggerType PASSWORD_REUSE_EVENT =
+    LoginReputationClientRequest_TriggerType_PASSWORD_REUSE_EVENT;
+  static inline bool TriggerType_IsValid(int value) {
+    return LoginReputationClientRequest_TriggerType_IsValid(value);
+  }
+  static constexpr TriggerType TriggerType_MIN =
+    LoginReputationClientRequest_TriggerType_TriggerType_MIN;
+  static constexpr TriggerType TriggerType_MAX =
+    LoginReputationClientRequest_TriggerType_TriggerType_MAX;
+  static constexpr int TriggerType_ARRAYSIZE =
+    LoginReputationClientRequest_TriggerType_TriggerType_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& TriggerType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, TriggerType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function TriggerType_Name.");
+    return LoginReputationClientRequest_TriggerType_Name(enum_t_value);
+  }
+  static inline bool TriggerType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      TriggerType* value) {
+    return LoginReputationClientRequest_TriggerType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFramesFieldNumber = 3,
+    kPageUrlFieldNumber = 1,
+    kPasswordReuseEventFieldNumber = 4,
+    kPopulationFieldNumber = 6,
+    kTriggerTypeFieldNumber = 2,
+    kStoredVerdictCntFieldNumber = 5,
+    kClickedThroughInterstitialFieldNumber = 7,
+  };
+  // repeated .safe_browsing.LoginReputationClientRequest.Frame frames = 3;
+  int frames_size() const;
+  private:
+  int _internal_frames_size() const;
+  public:
+  void clear_frames();
+  ::safe_browsing::LoginReputationClientRequest_Frame* mutable_frames(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::LoginReputationClientRequest_Frame >*
+      mutable_frames();
+  private:
+  const ::safe_browsing::LoginReputationClientRequest_Frame& _internal_frames(int index) const;
+  ::safe_browsing::LoginReputationClientRequest_Frame* _internal_add_frames();
+  public:
+  const ::safe_browsing::LoginReputationClientRequest_Frame& frames(int index) const;
+  ::safe_browsing::LoginReputationClientRequest_Frame* add_frames();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::LoginReputationClientRequest_Frame >&
+      frames() const;
+
+  // optional string page_url = 1;
+  bool has_page_url() const;
+  private:
+  bool _internal_has_page_url() const;
+  public:
+  void clear_page_url();
+  const std::string& page_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_page_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_page_url();
+  PROTOBUF_NODISCARD std::string* release_page_url();
+  void set_allocated_page_url(std::string* page_url);
+  private:
+  const std::string& _internal_page_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_page_url(const std::string& value);
+  std::string* _internal_mutable_page_url();
+  public:
+
+  // optional .safe_browsing.LoginReputationClientRequest.PasswordReuseEvent password_reuse_event = 4;
+  bool has_password_reuse_event() const;
+  private:
+  bool _internal_has_password_reuse_event() const;
+  public:
+  void clear_password_reuse_event();
+  const ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent& password_reuse_event() const;
+  PROTOBUF_NODISCARD ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* release_password_reuse_event();
+  ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* mutable_password_reuse_event();
+  void set_allocated_password_reuse_event(::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* password_reuse_event);
+  private:
+  const ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent& _internal_password_reuse_event() const;
+  ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* _internal_mutable_password_reuse_event();
+  public:
+  void unsafe_arena_set_allocated_password_reuse_event(
+      ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* password_reuse_event);
+  ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* unsafe_arena_release_password_reuse_event();
+
+  // optional .safe_browsing.ChromeUserPopulation population = 6;
+  bool has_population() const;
+  private:
+  bool _internal_has_population() const;
+  public:
+  void clear_population();
+  const ::safe_browsing::ChromeUserPopulation& population() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ChromeUserPopulation* release_population();
+  ::safe_browsing::ChromeUserPopulation* mutable_population();
+  void set_allocated_population(::safe_browsing::ChromeUserPopulation* population);
+  private:
+  const ::safe_browsing::ChromeUserPopulation& _internal_population() const;
+  ::safe_browsing::ChromeUserPopulation* _internal_mutable_population();
+  public:
+  void unsafe_arena_set_allocated_population(
+      ::safe_browsing::ChromeUserPopulation* population);
+  ::safe_browsing::ChromeUserPopulation* unsafe_arena_release_population();
+
+  // optional .safe_browsing.LoginReputationClientRequest.TriggerType trigger_type = 2;
+  bool has_trigger_type() const;
+  private:
+  bool _internal_has_trigger_type() const;
+  public:
+  void clear_trigger_type();
+  ::safe_browsing::LoginReputationClientRequest_TriggerType trigger_type() const;
+  void set_trigger_type(::safe_browsing::LoginReputationClientRequest_TriggerType value);
+  private:
+  ::safe_browsing::LoginReputationClientRequest_TriggerType _internal_trigger_type() const;
+  void _internal_set_trigger_type(::safe_browsing::LoginReputationClientRequest_TriggerType value);
+  public:
+
+  // optional int32 stored_verdict_cnt = 5;
+  bool has_stored_verdict_cnt() const;
+  private:
+  bool _internal_has_stored_verdict_cnt() const;
+  public:
+  void clear_stored_verdict_cnt();
+  int32_t stored_verdict_cnt() const;
+  void set_stored_verdict_cnt(int32_t value);
+  private:
+  int32_t _internal_stored_verdict_cnt() const;
+  void _internal_set_stored_verdict_cnt(int32_t value);
+  public:
+
+  // optional bool clicked_through_interstitial = 7;
+  bool has_clicked_through_interstitial() const;
+  private:
+  bool _internal_has_clicked_through_interstitial() const;
+  public:
+  void clear_clicked_through_interstitial();
+  bool clicked_through_interstitial() const;
+  void set_clicked_through_interstitial(bool value);
+  private:
+  bool _internal_clicked_through_interstitial() const;
+  void _internal_set_clicked_through_interstitial(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.LoginReputationClientRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::LoginReputationClientRequest_Frame > frames_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr page_url_;
+    ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* password_reuse_event_;
+    ::safe_browsing::ChromeUserPopulation* population_;
+    int trigger_type_;
+    int32_t stored_verdict_cnt_;
+    bool clicked_through_interstitial_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LoginReputationClientResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.LoginReputationClientResponse) */ {
+ public:
+  inline LoginReputationClientResponse() : LoginReputationClientResponse(nullptr) {}
+  ~LoginReputationClientResponse() override;
+  explicit PROTOBUF_CONSTEXPR LoginReputationClientResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LoginReputationClientResponse(const LoginReputationClientResponse& from);
+  LoginReputationClientResponse(LoginReputationClientResponse&& from) noexcept
+    : LoginReputationClientResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline LoginReputationClientResponse& operator=(const LoginReputationClientResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LoginReputationClientResponse& operator=(LoginReputationClientResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const LoginReputationClientResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LoginReputationClientResponse* internal_default_instance() {
+    return reinterpret_cast<const LoginReputationClientResponse*>(
+               &_LoginReputationClientResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(LoginReputationClientResponse& a, LoginReputationClientResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LoginReputationClientResponse* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LoginReputationClientResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  LoginReputationClientResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<LoginReputationClientResponse>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const LoginReputationClientResponse& from);
+  void MergeFrom(const LoginReputationClientResponse& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(LoginReputationClientResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.LoginReputationClientResponse";
+  }
+  protected:
+  explicit LoginReputationClientResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LoginReputationClientResponse_VerdictType VerdictType;
+  static constexpr VerdictType VERDICT_TYPE_UNSPECIFIED =
+    LoginReputationClientResponse_VerdictType_VERDICT_TYPE_UNSPECIFIED;
+  static constexpr VerdictType SAFE =
+    LoginReputationClientResponse_VerdictType_SAFE;
+  static constexpr VerdictType LOW_REPUTATION =
+    LoginReputationClientResponse_VerdictType_LOW_REPUTATION;
+  static constexpr VerdictType PHISHING =
+    LoginReputationClientResponse_VerdictType_PHISHING;
+  static inline bool VerdictType_IsValid(int value) {
+    return LoginReputationClientResponse_VerdictType_IsValid(value);
+  }
+  static constexpr VerdictType VerdictType_MIN =
+    LoginReputationClientResponse_VerdictType_VerdictType_MIN;
+  static constexpr VerdictType VerdictType_MAX =
+    LoginReputationClientResponse_VerdictType_VerdictType_MAX;
+  static constexpr int VerdictType_ARRAYSIZE =
+    LoginReputationClientResponse_VerdictType_VerdictType_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& VerdictType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, VerdictType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function VerdictType_Name.");
+    return LoginReputationClientResponse_VerdictType_Name(enum_t_value);
+  }
+  static inline bool VerdictType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      VerdictType* value) {
+    return LoginReputationClientResponse_VerdictType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCacheExpressionFieldNumber = 3,
+    kVerdictTokenFieldNumber = 5,
+    kCacheDurationSecFieldNumber = 2,
+    kVerdictTypeFieldNumber = 1,
+    kDEPRECATEDCacheExpressionExactMatchFieldNumber = 4,
+  };
+  // optional string cache_expression = 3;
+  bool has_cache_expression() const;
+  private:
+  bool _internal_has_cache_expression() const;
+  public:
+  void clear_cache_expression();
+  const std::string& cache_expression() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_cache_expression(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_cache_expression();
+  PROTOBUF_NODISCARD std::string* release_cache_expression();
+  void set_allocated_cache_expression(std::string* cache_expression);
+  private:
+  const std::string& _internal_cache_expression() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cache_expression(const std::string& value);
+  std::string* _internal_mutable_cache_expression();
+  public:
+
+  // optional bytes verdict_token = 5;
+  bool has_verdict_token() const;
+  private:
+  bool _internal_has_verdict_token() const;
+  public:
+  void clear_verdict_token();
+  const std::string& verdict_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_verdict_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_verdict_token();
+  PROTOBUF_NODISCARD std::string* release_verdict_token();
+  void set_allocated_verdict_token(std::string* verdict_token);
+  private:
+  const std::string& _internal_verdict_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_verdict_token(const std::string& value);
+  std::string* _internal_mutable_verdict_token();
+  public:
+
+  // optional int64 cache_duration_sec = 2;
+  bool has_cache_duration_sec() const;
+  private:
+  bool _internal_has_cache_duration_sec() const;
+  public:
+  void clear_cache_duration_sec();
+  int64_t cache_duration_sec() const;
+  void set_cache_duration_sec(int64_t value);
+  private:
+  int64_t _internal_cache_duration_sec() const;
+  void _internal_set_cache_duration_sec(int64_t value);
+  public:
+
+  // optional .safe_browsing.LoginReputationClientResponse.VerdictType verdict_type = 1;
+  bool has_verdict_type() const;
+  private:
+  bool _internal_has_verdict_type() const;
+  public:
+  void clear_verdict_type();
+  ::safe_browsing::LoginReputationClientResponse_VerdictType verdict_type() const;
+  void set_verdict_type(::safe_browsing::LoginReputationClientResponse_VerdictType value);
+  private:
+  ::safe_browsing::LoginReputationClientResponse_VerdictType _internal_verdict_type() const;
+  void _internal_set_verdict_type(::safe_browsing::LoginReputationClientResponse_VerdictType value);
+  public:
+
+  // optional bool DEPRECATED_cache_expression_exact_match = 4 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_deprecated_cache_expression_exact_match() const;
+  private:
+  bool _internal_has_deprecated_cache_expression_exact_match() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_deprecated_cache_expression_exact_match();
+  PROTOBUF_DEPRECATED bool deprecated_cache_expression_exact_match() const;
+  PROTOBUF_DEPRECATED void set_deprecated_cache_expression_exact_match(bool value);
+  private:
+  bool _internal_deprecated_cache_expression_exact_match() const;
+  void _internal_set_deprecated_cache_expression_exact_match(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.LoginReputationClientResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cache_expression_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verdict_token_;
+    int64_t cache_duration_sec_;
+    int verdict_type_;
+    bool deprecated_cache_expression_exact_match_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientMalwareResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientMalwareResponse) */ {
+ public:
+  inline ClientMalwareResponse() : ClientMalwareResponse(nullptr) {}
+  ~ClientMalwareResponse() override;
+  explicit PROTOBUF_CONSTEXPR ClientMalwareResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientMalwareResponse(const ClientMalwareResponse& from);
+  ClientMalwareResponse(ClientMalwareResponse&& from) noexcept
+    : ClientMalwareResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientMalwareResponse& operator=(const ClientMalwareResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientMalwareResponse& operator=(ClientMalwareResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientMalwareResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientMalwareResponse* internal_default_instance() {
+    return reinterpret_cast<const ClientMalwareResponse*>(
+               &_ClientMalwareResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(ClientMalwareResponse& a, ClientMalwareResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientMalwareResponse* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientMalwareResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientMalwareResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientMalwareResponse>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientMalwareResponse& from);
+  void MergeFrom(const ClientMalwareResponse& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientMalwareResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientMalwareResponse";
+  }
+  protected:
+  explicit ClientMalwareResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBadIpFieldNumber = 2,
+    kBadUrlFieldNumber = 3,
+    kBlacklistFieldNumber = 1,
+  };
+  // optional string bad_ip = 2;
+  bool has_bad_ip() const;
+  private:
+  bool _internal_has_bad_ip() const;
+  public:
+  void clear_bad_ip();
+  const std::string& bad_ip() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_bad_ip(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_bad_ip();
+  PROTOBUF_NODISCARD std::string* release_bad_ip();
+  void set_allocated_bad_ip(std::string* bad_ip);
+  private:
+  const std::string& _internal_bad_ip() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bad_ip(const std::string& value);
+  std::string* _internal_mutable_bad_ip();
+  public:
+
+  // optional string bad_url = 3;
+  bool has_bad_url() const;
+  private:
+  bool _internal_has_bad_url() const;
+  public:
+  void clear_bad_url();
+  const std::string& bad_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_bad_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_bad_url();
+  PROTOBUF_NODISCARD std::string* release_bad_url();
+  void set_allocated_bad_url(std::string* bad_url);
+  private:
+  const std::string& _internal_bad_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bad_url(const std::string& value);
+  std::string* _internal_mutable_bad_url();
+  public:
+
+  // required bool blacklist = 1;
+  bool has_blacklist() const;
+  private:
+  bool _internal_has_blacklist() const;
+  public:
+  void clear_blacklist();
+  bool blacklist() const;
+  void set_blacklist(bool value);
+  private:
+  bool _internal_blacklist() const;
+  void _internal_set_blacklist(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientMalwareResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bad_ip_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bad_url_;
+    bool blacklist_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_Digests final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.Digests) */ {
+ public:
+  inline ClientDownloadRequest_Digests() : ClientDownloadRequest_Digests(nullptr) {}
+  ~ClientDownloadRequest_Digests() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadRequest_Digests(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadRequest_Digests(const ClientDownloadRequest_Digests& from);
+  ClientDownloadRequest_Digests(ClientDownloadRequest_Digests&& from) noexcept
+    : ClientDownloadRequest_Digests() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadRequest_Digests& operator=(const ClientDownloadRequest_Digests& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadRequest_Digests& operator=(ClientDownloadRequest_Digests&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadRequest_Digests& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadRequest_Digests* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadRequest_Digests*>(
+               &_ClientDownloadRequest_Digests_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(ClientDownloadRequest_Digests& a, ClientDownloadRequest_Digests& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadRequest_Digests* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadRequest_Digests* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_Digests* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadRequest_Digests>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadRequest_Digests& from);
+  void MergeFrom(const ClientDownloadRequest_Digests& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadRequest_Digests* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadRequest.Digests";
+  }
+  protected:
+  explicit ClientDownloadRequest_Digests(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSha256FieldNumber = 1,
+    kSha1FieldNumber = 2,
+    kMd5FieldNumber = 3,
+  };
+  // optional bytes sha256 = 1;
+  bool has_sha256() const;
+  private:
+  bool _internal_has_sha256() const;
+  public:
+  void clear_sha256();
+  const std::string& sha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_sha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_sha256();
+  PROTOBUF_NODISCARD std::string* release_sha256();
+  void set_allocated_sha256(std::string* sha256);
+  private:
+  const std::string& _internal_sha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sha256(const std::string& value);
+  std::string* _internal_mutable_sha256();
+  public:
+
+  // optional bytes sha1 = 2;
+  bool has_sha1() const;
+  private:
+  bool _internal_has_sha1() const;
+  public:
+  void clear_sha1();
+  const std::string& sha1() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_sha1(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_sha1();
+  PROTOBUF_NODISCARD std::string* release_sha1();
+  void set_allocated_sha1(std::string* sha1);
+  private:
+  const std::string& _internal_sha1() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sha1(const std::string& value);
+  std::string* _internal_mutable_sha1();
+  public:
+
+  // optional bytes md5 = 3;
+  bool has_md5() const;
+  private:
+  bool _internal_has_md5() const;
+  public:
+  void clear_md5();
+  const std::string& md5() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_md5(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_md5();
+  PROTOBUF_NODISCARD std::string* release_md5();
+  void set_allocated_md5(std::string* md5);
+  private:
+  const std::string& _internal_md5() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_md5(const std::string& value);
+  std::string* _internal_mutable_md5();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.Digests)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sha1_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr md5_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_Resource final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.Resource) */ {
+ public:
+  inline ClientDownloadRequest_Resource() : ClientDownloadRequest_Resource(nullptr) {}
+  ~ClientDownloadRequest_Resource() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadRequest_Resource(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadRequest_Resource(const ClientDownloadRequest_Resource& from);
+  ClientDownloadRequest_Resource(ClientDownloadRequest_Resource&& from) noexcept
+    : ClientDownloadRequest_Resource() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadRequest_Resource& operator=(const ClientDownloadRequest_Resource& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadRequest_Resource& operator=(ClientDownloadRequest_Resource&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadRequest_Resource& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadRequest_Resource* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadRequest_Resource*>(
+               &_ClientDownloadRequest_Resource_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(ClientDownloadRequest_Resource& a, ClientDownloadRequest_Resource& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadRequest_Resource* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadRequest_Resource* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_Resource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadRequest_Resource>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadRequest_Resource& from);
+  void MergeFrom(const ClientDownloadRequest_Resource& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadRequest_Resource* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadRequest.Resource";
+  }
+  protected:
+  explicit ClientDownloadRequest_Resource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUrlFieldNumber = 1,
+    kRemoteIpFieldNumber = 3,
+    kReferrerFieldNumber = 4,
+    kTypeFieldNumber = 2,
+  };
+  // required string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional bytes remote_ip = 3;
+  bool has_remote_ip() const;
+  private:
+  bool _internal_has_remote_ip() const;
+  public:
+  void clear_remote_ip();
+  const std::string& remote_ip() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_remote_ip(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_remote_ip();
+  PROTOBUF_NODISCARD std::string* release_remote_ip();
+  void set_allocated_remote_ip(std::string* remote_ip);
+  private:
+  const std::string& _internal_remote_ip() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_remote_ip(const std::string& value);
+  std::string* _internal_mutable_remote_ip();
+  public:
+
+  // optional string referrer = 4;
+  bool has_referrer() const;
+  private:
+  bool _internal_has_referrer() const;
+  public:
+  void clear_referrer();
+  const std::string& referrer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_referrer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_referrer();
+  PROTOBUF_NODISCARD std::string* release_referrer();
+  void set_allocated_referrer(std::string* referrer);
+  private:
+  const std::string& _internal_referrer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_referrer(const std::string& value);
+  std::string* _internal_mutable_referrer();
+  public:
+
+  // required .safe_browsing.ClientDownloadRequest.ResourceType type = 2;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::safe_browsing::ClientDownloadRequest_ResourceType type() const;
+  void set_type(::safe_browsing::ClientDownloadRequest_ResourceType value);
+  private:
+  ::safe_browsing::ClientDownloadRequest_ResourceType _internal_type() const;
+  void _internal_set_type(::safe_browsing::ClientDownloadRequest_ResourceType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.Resource)
+ private:
+  class _Internal;
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remote_ip_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr referrer_;
+    int type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_CertificateChain_Element final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.CertificateChain.Element) */ {
+ public:
+  inline ClientDownloadRequest_CertificateChain_Element() : ClientDownloadRequest_CertificateChain_Element(nullptr) {}
+  ~ClientDownloadRequest_CertificateChain_Element() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadRequest_CertificateChain_Element(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadRequest_CertificateChain_Element(const ClientDownloadRequest_CertificateChain_Element& from);
+  ClientDownloadRequest_CertificateChain_Element(ClientDownloadRequest_CertificateChain_Element&& from) noexcept
+    : ClientDownloadRequest_CertificateChain_Element() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadRequest_CertificateChain_Element& operator=(const ClientDownloadRequest_CertificateChain_Element& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadRequest_CertificateChain_Element& operator=(ClientDownloadRequest_CertificateChain_Element&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadRequest_CertificateChain_Element& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadRequest_CertificateChain_Element* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadRequest_CertificateChain_Element*>(
+               &_ClientDownloadRequest_CertificateChain_Element_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  friend void swap(ClientDownloadRequest_CertificateChain_Element& a, ClientDownloadRequest_CertificateChain_Element& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadRequest_CertificateChain_Element* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadRequest_CertificateChain_Element* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_CertificateChain_Element* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadRequest_CertificateChain_Element>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadRequest_CertificateChain_Element& from);
+  void MergeFrom(const ClientDownloadRequest_CertificateChain_Element& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadRequest_CertificateChain_Element* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadRequest.CertificateChain.Element";
+  }
+  protected:
+  explicit ClientDownloadRequest_CertificateChain_Element(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCertificateFieldNumber = 1,
+  };
+  // optional bytes certificate = 1;
+  bool has_certificate() const;
+  private:
+  bool _internal_has_certificate() const;
+  public:
+  void clear_certificate();
+  const std::string& certificate() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_certificate(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_certificate();
+  PROTOBUF_NODISCARD std::string* release_certificate();
+  void set_allocated_certificate(std::string* certificate);
+  private:
+  const std::string& _internal_certificate() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate(const std::string& value);
+  std::string* _internal_mutable_certificate();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_CertificateChain final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.CertificateChain) */ {
+ public:
+  inline ClientDownloadRequest_CertificateChain() : ClientDownloadRequest_CertificateChain(nullptr) {}
+  ~ClientDownloadRequest_CertificateChain() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadRequest_CertificateChain(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadRequest_CertificateChain(const ClientDownloadRequest_CertificateChain& from);
+  ClientDownloadRequest_CertificateChain(ClientDownloadRequest_CertificateChain&& from) noexcept
+    : ClientDownloadRequest_CertificateChain() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadRequest_CertificateChain& operator=(const ClientDownloadRequest_CertificateChain& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadRequest_CertificateChain& operator=(ClientDownloadRequest_CertificateChain&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadRequest_CertificateChain& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadRequest_CertificateChain* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadRequest_CertificateChain*>(
+               &_ClientDownloadRequest_CertificateChain_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  friend void swap(ClientDownloadRequest_CertificateChain& a, ClientDownloadRequest_CertificateChain& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadRequest_CertificateChain* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadRequest_CertificateChain* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_CertificateChain* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadRequest_CertificateChain>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadRequest_CertificateChain& from);
+  void MergeFrom(const ClientDownloadRequest_CertificateChain& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadRequest_CertificateChain* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadRequest.CertificateChain";
+  }
+  protected:
+  explicit ClientDownloadRequest_CertificateChain(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientDownloadRequest_CertificateChain_Element Element;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kElementFieldNumber = 1,
+  };
+  // repeated .safe_browsing.ClientDownloadRequest.CertificateChain.Element element = 1;
+  int element_size() const;
+  private:
+  int _internal_element_size() const;
+  public:
+  void clear_element();
+  ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* mutable_element(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >*
+      mutable_element();
+  private:
+  const ::safe_browsing::ClientDownloadRequest_CertificateChain_Element& _internal_element(int index) const;
+  ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* _internal_add_element();
+  public:
+  const ::safe_browsing::ClientDownloadRequest_CertificateChain_Element& element(int index) const;
+  ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* add_element();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >&
+      element() const;
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.CertificateChain)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element > element_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_ExtendedAttr final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.ExtendedAttr) */ {
+ public:
+  inline ClientDownloadRequest_ExtendedAttr() : ClientDownloadRequest_ExtendedAttr(nullptr) {}
+  ~ClientDownloadRequest_ExtendedAttr() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadRequest_ExtendedAttr(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadRequest_ExtendedAttr(const ClientDownloadRequest_ExtendedAttr& from);
+  ClientDownloadRequest_ExtendedAttr(ClientDownloadRequest_ExtendedAttr&& from) noexcept
+    : ClientDownloadRequest_ExtendedAttr() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadRequest_ExtendedAttr& operator=(const ClientDownloadRequest_ExtendedAttr& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadRequest_ExtendedAttr& operator=(ClientDownloadRequest_ExtendedAttr&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadRequest_ExtendedAttr& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadRequest_ExtendedAttr* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadRequest_ExtendedAttr*>(
+               &_ClientDownloadRequest_ExtendedAttr_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  friend void swap(ClientDownloadRequest_ExtendedAttr& a, ClientDownloadRequest_ExtendedAttr& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadRequest_ExtendedAttr* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadRequest_ExtendedAttr* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_ExtendedAttr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadRequest_ExtendedAttr>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadRequest_ExtendedAttr& from);
+  void MergeFrom(const ClientDownloadRequest_ExtendedAttr& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadRequest_ExtendedAttr* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadRequest.ExtendedAttr";
+  }
+  protected:
+  explicit ClientDownloadRequest_ExtendedAttr(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  // required string key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const std::string& key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key();
+  PROTOBUF_NODISCARD std::string* release_key();
+  void set_allocated_key(std::string* key);
+  private:
+  const std::string& _internal_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
+  std::string* _internal_mutable_key();
+  public:
+
+  // optional bytes value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const std::string& value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_value();
+  PROTOBUF_NODISCARD std::string* release_value();
+  void set_allocated_value(std::string* value);
+  private:
+  const std::string& _internal_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+  std::string* _internal_mutable_value();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_SignatureInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.SignatureInfo) */ {
+ public:
+  inline ClientDownloadRequest_SignatureInfo() : ClientDownloadRequest_SignatureInfo(nullptr) {}
+  ~ClientDownloadRequest_SignatureInfo() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadRequest_SignatureInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadRequest_SignatureInfo(const ClientDownloadRequest_SignatureInfo& from);
+  ClientDownloadRequest_SignatureInfo(ClientDownloadRequest_SignatureInfo&& from) noexcept
+    : ClientDownloadRequest_SignatureInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadRequest_SignatureInfo& operator=(const ClientDownloadRequest_SignatureInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadRequest_SignatureInfo& operator=(ClientDownloadRequest_SignatureInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadRequest_SignatureInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadRequest_SignatureInfo* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadRequest_SignatureInfo*>(
+               &_ClientDownloadRequest_SignatureInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  friend void swap(ClientDownloadRequest_SignatureInfo& a, ClientDownloadRequest_SignatureInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadRequest_SignatureInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadRequest_SignatureInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_SignatureInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadRequest_SignatureInfo>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadRequest_SignatureInfo& from);
+  void MergeFrom(const ClientDownloadRequest_SignatureInfo& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadRequest_SignatureInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadRequest.SignatureInfo";
+  }
+  protected:
+  explicit ClientDownloadRequest_SignatureInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCertificateChainFieldNumber = 1,
+    kSignedDataFieldNumber = 3,
+    kXattrFieldNumber = 4,
+    kTrustedFieldNumber = 2,
+  };
+  // repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1;
+  int certificate_chain_size() const;
+  private:
+  int _internal_certificate_chain_size() const;
+  public:
+  void clear_certificate_chain();
+  ::safe_browsing::ClientDownloadRequest_CertificateChain* mutable_certificate_chain(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain >*
+      mutable_certificate_chain();
+  private:
+  const ::safe_browsing::ClientDownloadRequest_CertificateChain& _internal_certificate_chain(int index) const;
+  ::safe_browsing::ClientDownloadRequest_CertificateChain* _internal_add_certificate_chain();
+  public:
+  const ::safe_browsing::ClientDownloadRequest_CertificateChain& certificate_chain(int index) const;
+  ::safe_browsing::ClientDownloadRequest_CertificateChain* add_certificate_chain();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain >&
+      certificate_chain() const;
+
+  // repeated bytes signed_data = 3;
+  int signed_data_size() const;
+  private:
+  int _internal_signed_data_size() const;
+  public:
+  void clear_signed_data();
+  const std::string& signed_data(int index) const;
+  std::string* mutable_signed_data(int index);
+  void set_signed_data(int index, const std::string& value);
+  void set_signed_data(int index, std::string&& value);
+  void set_signed_data(int index, const char* value);
+  void set_signed_data(int index, const void* value, size_t size);
+  std::string* add_signed_data();
+  void add_signed_data(const std::string& value);
+  void add_signed_data(std::string&& value);
+  void add_signed_data(const char* value);
+  void add_signed_data(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& signed_data() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_signed_data();
+  private:
+  const std::string& _internal_signed_data(int index) const;
+  std::string* _internal_add_signed_data();
+  public:
+
+  // repeated .safe_browsing.ClientDownloadRequest.ExtendedAttr xattr = 4;
+  int xattr_size() const;
+  private:
+  int _internal_xattr_size() const;
+  public:
+  void clear_xattr();
+  ::safe_browsing::ClientDownloadRequest_ExtendedAttr* mutable_xattr(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ExtendedAttr >*
+      mutable_xattr();
+  private:
+  const ::safe_browsing::ClientDownloadRequest_ExtendedAttr& _internal_xattr(int index) const;
+  ::safe_browsing::ClientDownloadRequest_ExtendedAttr* _internal_add_xattr();
+  public:
+  const ::safe_browsing::ClientDownloadRequest_ExtendedAttr& xattr(int index) const;
+  ::safe_browsing::ClientDownloadRequest_ExtendedAttr* add_xattr();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ExtendedAttr >&
+      xattr() const;
+
+  // optional bool trusted = 2;
+  bool has_trusted() const;
+  private:
+  bool _internal_has_trusted() const;
+  public:
+  void clear_trusted();
+  bool trusted() const;
+  void set_trusted(bool value);
+  private:
+  bool _internal_trusted() const;
+  void _internal_set_trusted(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.SignatureInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain > certificate_chain_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> signed_data_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ExtendedAttr > xattr_;
+    bool trusted_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_PEImageHeaders_DebugData final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData) */ {
+ public:
+  inline ClientDownloadRequest_PEImageHeaders_DebugData() : ClientDownloadRequest_PEImageHeaders_DebugData(nullptr) {}
+  ~ClientDownloadRequest_PEImageHeaders_DebugData() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadRequest_PEImageHeaders_DebugData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadRequest_PEImageHeaders_DebugData(const ClientDownloadRequest_PEImageHeaders_DebugData& from);
+  ClientDownloadRequest_PEImageHeaders_DebugData(ClientDownloadRequest_PEImageHeaders_DebugData&& from) noexcept
+    : ClientDownloadRequest_PEImageHeaders_DebugData() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadRequest_PEImageHeaders_DebugData& operator=(const ClientDownloadRequest_PEImageHeaders_DebugData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadRequest_PEImageHeaders_DebugData& operator=(ClientDownloadRequest_PEImageHeaders_DebugData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadRequest_PEImageHeaders_DebugData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadRequest_PEImageHeaders_DebugData* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadRequest_PEImageHeaders_DebugData*>(
+               &_ClientDownloadRequest_PEImageHeaders_DebugData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  friend void swap(ClientDownloadRequest_PEImageHeaders_DebugData& a, ClientDownloadRequest_PEImageHeaders_DebugData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadRequest_PEImageHeaders_DebugData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadRequest_PEImageHeaders_DebugData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_PEImageHeaders_DebugData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadRequest_PEImageHeaders_DebugData>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadRequest_PEImageHeaders_DebugData& from);
+  void MergeFrom(const ClientDownloadRequest_PEImageHeaders_DebugData& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadRequest_PEImageHeaders_DebugData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData";
+  }
+  protected:
+  explicit ClientDownloadRequest_PEImageHeaders_DebugData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDirectoryEntryFieldNumber = 1,
+    kRawDataFieldNumber = 2,
+  };
+  // optional bytes directory_entry = 1;
+  bool has_directory_entry() const;
+  private:
+  bool _internal_has_directory_entry() const;
+  public:
+  void clear_directory_entry();
+  const std::string& directory_entry() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_directory_entry(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_directory_entry();
+  PROTOBUF_NODISCARD std::string* release_directory_entry();
+  void set_allocated_directory_entry(std::string* directory_entry);
+  private:
+  const std::string& _internal_directory_entry() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directory_entry(const std::string& value);
+  std::string* _internal_mutable_directory_entry();
+  public:
+
+  // optional bytes raw_data = 2;
+  bool has_raw_data() const;
+  private:
+  bool _internal_has_raw_data() const;
+  public:
+  void clear_raw_data();
+  const std::string& raw_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_raw_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_raw_data();
+  PROTOBUF_NODISCARD std::string* release_raw_data();
+  void set_allocated_raw_data(std::string* raw_data);
+  private:
+  const std::string& _internal_raw_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_raw_data(const std::string& value);
+  std::string* _internal_mutable_raw_data();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directory_entry_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_data_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_PEImageHeaders final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.PEImageHeaders) */ {
+ public:
+  inline ClientDownloadRequest_PEImageHeaders() : ClientDownloadRequest_PEImageHeaders(nullptr) {}
+  ~ClientDownloadRequest_PEImageHeaders() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadRequest_PEImageHeaders(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadRequest_PEImageHeaders(const ClientDownloadRequest_PEImageHeaders& from);
+  ClientDownloadRequest_PEImageHeaders(ClientDownloadRequest_PEImageHeaders&& from) noexcept
+    : ClientDownloadRequest_PEImageHeaders() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadRequest_PEImageHeaders& operator=(const ClientDownloadRequest_PEImageHeaders& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadRequest_PEImageHeaders& operator=(ClientDownloadRequest_PEImageHeaders&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadRequest_PEImageHeaders& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadRequest_PEImageHeaders* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadRequest_PEImageHeaders*>(
+               &_ClientDownloadRequest_PEImageHeaders_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    19;
+
+  friend void swap(ClientDownloadRequest_PEImageHeaders& a, ClientDownloadRequest_PEImageHeaders& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadRequest_PEImageHeaders* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadRequest_PEImageHeaders* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_PEImageHeaders* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadRequest_PEImageHeaders>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadRequest_PEImageHeaders& from);
+  void MergeFrom(const ClientDownloadRequest_PEImageHeaders& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadRequest_PEImageHeaders* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadRequest.PEImageHeaders";
+  }
+  protected:
+  explicit ClientDownloadRequest_PEImageHeaders(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientDownloadRequest_PEImageHeaders_DebugData DebugData;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSectionHeaderFieldNumber = 5,
+    kDebugDataFieldNumber = 7,
+    kDosHeaderFieldNumber = 1,
+    kFileHeaderFieldNumber = 2,
+    kOptionalHeaders32FieldNumber = 3,
+    kOptionalHeaders64FieldNumber = 4,
+    kExportSectionDataFieldNumber = 6,
+  };
+  // repeated bytes section_header = 5;
+  int section_header_size() const;
+  private:
+  int _internal_section_header_size() const;
+  public:
+  void clear_section_header();
+  const std::string& section_header(int index) const;
+  std::string* mutable_section_header(int index);
+  void set_section_header(int index, const std::string& value);
+  void set_section_header(int index, std::string&& value);
+  void set_section_header(int index, const char* value);
+  void set_section_header(int index, const void* value, size_t size);
+  std::string* add_section_header();
+  void add_section_header(const std::string& value);
+  void add_section_header(std::string&& value);
+  void add_section_header(const char* value);
+  void add_section_header(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& section_header() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_section_header();
+  private:
+  const std::string& _internal_section_header(int index) const;
+  std::string* _internal_add_section_header();
+  public:
+
+  // repeated .safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData debug_data = 7;
+  int debug_data_size() const;
+  private:
+  int _internal_debug_data_size() const;
+  public:
+  void clear_debug_data();
+  ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData* mutable_debug_data(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData >*
+      mutable_debug_data();
+  private:
+  const ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData& _internal_debug_data(int index) const;
+  ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData* _internal_add_debug_data();
+  public:
+  const ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData& debug_data(int index) const;
+  ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData* add_debug_data();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData >&
+      debug_data() const;
+
+  // optional bytes dos_header = 1;
+  bool has_dos_header() const;
+  private:
+  bool _internal_has_dos_header() const;
+  public:
+  void clear_dos_header();
+  const std::string& dos_header() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_dos_header(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_dos_header();
+  PROTOBUF_NODISCARD std::string* release_dos_header();
+  void set_allocated_dos_header(std::string* dos_header);
+  private:
+  const std::string& _internal_dos_header() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dos_header(const std::string& value);
+  std::string* _internal_mutable_dos_header();
+  public:
+
+  // optional bytes file_header = 2;
+  bool has_file_header() const;
+  private:
+  bool _internal_has_file_header() const;
+  public:
+  void clear_file_header();
+  const std::string& file_header() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_file_header(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_file_header();
+  PROTOBUF_NODISCARD std::string* release_file_header();
+  void set_allocated_file_header(std::string* file_header);
+  private:
+  const std::string& _internal_file_header() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_header(const std::string& value);
+  std::string* _internal_mutable_file_header();
+  public:
+
+  // optional bytes optional_headers32 = 3;
+  bool has_optional_headers32() const;
+  private:
+  bool _internal_has_optional_headers32() const;
+  public:
+  void clear_optional_headers32();
+  const std::string& optional_headers32() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_optional_headers32(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_optional_headers32();
+  PROTOBUF_NODISCARD std::string* release_optional_headers32();
+  void set_allocated_optional_headers32(std::string* optional_headers32);
+  private:
+  const std::string& _internal_optional_headers32() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_optional_headers32(const std::string& value);
+  std::string* _internal_mutable_optional_headers32();
+  public:
+
+  // optional bytes optional_headers64 = 4;
+  bool has_optional_headers64() const;
+  private:
+  bool _internal_has_optional_headers64() const;
+  public:
+  void clear_optional_headers64();
+  const std::string& optional_headers64() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_optional_headers64(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_optional_headers64();
+  PROTOBUF_NODISCARD std::string* release_optional_headers64();
+  void set_allocated_optional_headers64(std::string* optional_headers64);
+  private:
+  const std::string& _internal_optional_headers64() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_optional_headers64(const std::string& value);
+  std::string* _internal_mutable_optional_headers64();
+  public:
+
+  // optional bytes export_section_data = 6;
+  bool has_export_section_data() const;
+  private:
+  bool _internal_has_export_section_data() const;
+  public:
+  void clear_export_section_data();
+  const std::string& export_section_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_export_section_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_export_section_data();
+  PROTOBUF_NODISCARD std::string* release_export_section_data();
+  void set_allocated_export_section_data(std::string* export_section_data);
+  private:
+  const std::string& _internal_export_section_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_export_section_data(const std::string& value);
+  std::string* _internal_mutable_export_section_data();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> section_header_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData > debug_data_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dos_header_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_header_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr optional_headers32_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr optional_headers64_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr export_section_data_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_MachOHeaders_LoadCommand final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand) */ {
+ public:
+  inline ClientDownloadRequest_MachOHeaders_LoadCommand() : ClientDownloadRequest_MachOHeaders_LoadCommand(nullptr) {}
+  ~ClientDownloadRequest_MachOHeaders_LoadCommand() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadRequest_MachOHeaders_LoadCommand(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadRequest_MachOHeaders_LoadCommand(const ClientDownloadRequest_MachOHeaders_LoadCommand& from);
+  ClientDownloadRequest_MachOHeaders_LoadCommand(ClientDownloadRequest_MachOHeaders_LoadCommand&& from) noexcept
+    : ClientDownloadRequest_MachOHeaders_LoadCommand() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadRequest_MachOHeaders_LoadCommand& operator=(const ClientDownloadRequest_MachOHeaders_LoadCommand& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadRequest_MachOHeaders_LoadCommand& operator=(ClientDownloadRequest_MachOHeaders_LoadCommand&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadRequest_MachOHeaders_LoadCommand& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadRequest_MachOHeaders_LoadCommand* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadRequest_MachOHeaders_LoadCommand*>(
+               &_ClientDownloadRequest_MachOHeaders_LoadCommand_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    20;
+
+  friend void swap(ClientDownloadRequest_MachOHeaders_LoadCommand& a, ClientDownloadRequest_MachOHeaders_LoadCommand& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadRequest_MachOHeaders_LoadCommand* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadRequest_MachOHeaders_LoadCommand* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_MachOHeaders_LoadCommand* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadRequest_MachOHeaders_LoadCommand>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadRequest_MachOHeaders_LoadCommand& from);
+  void MergeFrom(const ClientDownloadRequest_MachOHeaders_LoadCommand& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadRequest_MachOHeaders_LoadCommand* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand";
+  }
+  protected:
+  explicit ClientDownloadRequest_MachOHeaders_LoadCommand(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCommandFieldNumber = 2,
+    kCommandIdFieldNumber = 1,
+  };
+  // required bytes command = 2;
+  bool has_command() const;
+  private:
+  bool _internal_has_command() const;
+  public:
+  void clear_command();
+  const std::string& command() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_command(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_command();
+  PROTOBUF_NODISCARD std::string* release_command();
+  void set_allocated_command(std::string* command);
+  private:
+  const std::string& _internal_command() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_command(const std::string& value);
+  std::string* _internal_mutable_command();
+  public:
+
+  // required uint32 command_id = 1;
+  bool has_command_id() const;
+  private:
+  bool _internal_has_command_id() const;
+  public:
+  void clear_command_id();
+  uint32_t command_id() const;
+  void set_command_id(uint32_t value);
+  private:
+  uint32_t _internal_command_id() const;
+  void _internal_set_command_id(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+ private:
+  class _Internal;
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr command_;
+    uint32_t command_id_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_MachOHeaders final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.MachOHeaders) */ {
+ public:
+  inline ClientDownloadRequest_MachOHeaders() : ClientDownloadRequest_MachOHeaders(nullptr) {}
+  ~ClientDownloadRequest_MachOHeaders() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadRequest_MachOHeaders(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadRequest_MachOHeaders(const ClientDownloadRequest_MachOHeaders& from);
+  ClientDownloadRequest_MachOHeaders(ClientDownloadRequest_MachOHeaders&& from) noexcept
+    : ClientDownloadRequest_MachOHeaders() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadRequest_MachOHeaders& operator=(const ClientDownloadRequest_MachOHeaders& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadRequest_MachOHeaders& operator=(ClientDownloadRequest_MachOHeaders&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadRequest_MachOHeaders& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadRequest_MachOHeaders* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadRequest_MachOHeaders*>(
+               &_ClientDownloadRequest_MachOHeaders_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    21;
+
+  friend void swap(ClientDownloadRequest_MachOHeaders& a, ClientDownloadRequest_MachOHeaders& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadRequest_MachOHeaders* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadRequest_MachOHeaders* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_MachOHeaders* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadRequest_MachOHeaders>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadRequest_MachOHeaders& from);
+  void MergeFrom(const ClientDownloadRequest_MachOHeaders& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadRequest_MachOHeaders* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadRequest.MachOHeaders";
+  }
+  protected:
+  explicit ClientDownloadRequest_MachOHeaders(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientDownloadRequest_MachOHeaders_LoadCommand LoadCommand;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLoadCommandsFieldNumber = 2,
+    kMachHeaderFieldNumber = 1,
+  };
+  // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand load_commands = 2;
+  int load_commands_size() const;
+  private:
+  int _internal_load_commands_size() const;
+  public:
+  void clear_load_commands();
+  ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand* mutable_load_commands(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand >*
+      mutable_load_commands();
+  private:
+  const ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand& _internal_load_commands(int index) const;
+  ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand* _internal_add_load_commands();
+  public:
+  const ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand& load_commands(int index) const;
+  ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand* add_load_commands();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand >&
+      load_commands() const;
+
+  // required bytes mach_header = 1;
+  bool has_mach_header() const;
+  private:
+  bool _internal_has_mach_header() const;
+  public:
+  void clear_mach_header();
+  const std::string& mach_header() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mach_header(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mach_header();
+  PROTOBUF_NODISCARD std::string* release_mach_header();
+  void set_allocated_mach_header(std::string* mach_header);
+  private:
+  const std::string& _internal_mach_header() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mach_header(const std::string& value);
+  std::string* _internal_mutable_mach_header();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.MachOHeaders)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand > load_commands_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mach_header_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_ImageHeaders final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.ImageHeaders) */ {
+ public:
+  inline ClientDownloadRequest_ImageHeaders() : ClientDownloadRequest_ImageHeaders(nullptr) {}
+  ~ClientDownloadRequest_ImageHeaders() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadRequest_ImageHeaders(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadRequest_ImageHeaders(const ClientDownloadRequest_ImageHeaders& from);
+  ClientDownloadRequest_ImageHeaders(ClientDownloadRequest_ImageHeaders&& from) noexcept
+    : ClientDownloadRequest_ImageHeaders() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadRequest_ImageHeaders& operator=(const ClientDownloadRequest_ImageHeaders& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadRequest_ImageHeaders& operator=(ClientDownloadRequest_ImageHeaders&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadRequest_ImageHeaders& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadRequest_ImageHeaders* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadRequest_ImageHeaders*>(
+               &_ClientDownloadRequest_ImageHeaders_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    22;
+
+  friend void swap(ClientDownloadRequest_ImageHeaders& a, ClientDownloadRequest_ImageHeaders& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadRequest_ImageHeaders* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadRequest_ImageHeaders* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_ImageHeaders* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadRequest_ImageHeaders>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadRequest_ImageHeaders& from);
+  void MergeFrom(const ClientDownloadRequest_ImageHeaders& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadRequest_ImageHeaders* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadRequest.ImageHeaders";
+  }
+  protected:
+  explicit ClientDownloadRequest_ImageHeaders(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMachOHeadersFieldNumber = 2,
+    kPeHeadersFieldNumber = 1,
+  };
+  // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders mach_o_headers = 2;
+  int mach_o_headers_size() const;
+  private:
+  int _internal_mach_o_headers_size() const;
+  public:
+  void clear_mach_o_headers();
+  ::safe_browsing::ClientDownloadRequest_MachOHeaders* mutable_mach_o_headers(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders >*
+      mutable_mach_o_headers();
+  private:
+  const ::safe_browsing::ClientDownloadRequest_MachOHeaders& _internal_mach_o_headers(int index) const;
+  ::safe_browsing::ClientDownloadRequest_MachOHeaders* _internal_add_mach_o_headers();
+  public:
+  const ::safe_browsing::ClientDownloadRequest_MachOHeaders& mach_o_headers(int index) const;
+  ::safe_browsing::ClientDownloadRequest_MachOHeaders* add_mach_o_headers();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders >&
+      mach_o_headers() const;
+
+  // optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1;
+  bool has_pe_headers() const;
+  private:
+  bool _internal_has_pe_headers() const;
+  public:
+  void clear_pe_headers();
+  const ::safe_browsing::ClientDownloadRequest_PEImageHeaders& pe_headers() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest_PEImageHeaders* release_pe_headers();
+  ::safe_browsing::ClientDownloadRequest_PEImageHeaders* mutable_pe_headers();
+  void set_allocated_pe_headers(::safe_browsing::ClientDownloadRequest_PEImageHeaders* pe_headers);
+  private:
+  const ::safe_browsing::ClientDownloadRequest_PEImageHeaders& _internal_pe_headers() const;
+  ::safe_browsing::ClientDownloadRequest_PEImageHeaders* _internal_mutable_pe_headers();
+  public:
+  void unsafe_arena_set_allocated_pe_headers(
+      ::safe_browsing::ClientDownloadRequest_PEImageHeaders* pe_headers);
+  ::safe_browsing::ClientDownloadRequest_PEImageHeaders* unsafe_arena_release_pe_headers();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.ImageHeaders)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders > mach_o_headers_;
+    ::safe_browsing::ClientDownloadRequest_PEImageHeaders* pe_headers_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_ArchivedBinary final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.ArchivedBinary) */ {
+ public:
+  inline ClientDownloadRequest_ArchivedBinary() : ClientDownloadRequest_ArchivedBinary(nullptr) {}
+  ~ClientDownloadRequest_ArchivedBinary() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadRequest_ArchivedBinary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadRequest_ArchivedBinary(const ClientDownloadRequest_ArchivedBinary& from);
+  ClientDownloadRequest_ArchivedBinary(ClientDownloadRequest_ArchivedBinary&& from) noexcept
+    : ClientDownloadRequest_ArchivedBinary() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadRequest_ArchivedBinary& operator=(const ClientDownloadRequest_ArchivedBinary& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadRequest_ArchivedBinary& operator=(ClientDownloadRequest_ArchivedBinary&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadRequest_ArchivedBinary& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadRequest_ArchivedBinary* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadRequest_ArchivedBinary*>(
+               &_ClientDownloadRequest_ArchivedBinary_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    23;
+
+  friend void swap(ClientDownloadRequest_ArchivedBinary& a, ClientDownloadRequest_ArchivedBinary& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadRequest_ArchivedBinary* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadRequest_ArchivedBinary* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_ArchivedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadRequest_ArchivedBinary>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadRequest_ArchivedBinary& from);
+  void MergeFrom(const ClientDownloadRequest_ArchivedBinary& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadRequest_ArchivedBinary* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadRequest.ArchivedBinary";
+  }
+  protected:
+  explicit ClientDownloadRequest_ArchivedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFileBasenameFieldNumber = 1,
+    kDigestsFieldNumber = 3,
+    kSignatureFieldNumber = 5,
+    kImageHeadersFieldNumber = 6,
+    kLengthFieldNumber = 4,
+    kDownloadTypeFieldNumber = 2,
+  };
+  // optional string file_basename = 1;
+  bool has_file_basename() const;
+  private:
+  bool _internal_has_file_basename() const;
+  public:
+  void clear_file_basename();
+  const std::string& file_basename() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_file_basename(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_file_basename();
+  PROTOBUF_NODISCARD std::string* release_file_basename();
+  void set_allocated_file_basename(std::string* file_basename);
+  private:
+  const std::string& _internal_file_basename() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_basename(const std::string& value);
+  std::string* _internal_mutable_file_basename();
+  public:
+
+  // optional .safe_browsing.ClientDownloadRequest.Digests digests = 3;
+  bool has_digests() const;
+  private:
+  bool _internal_has_digests() const;
+  public:
+  void clear_digests();
+  const ::safe_browsing::ClientDownloadRequest_Digests& digests() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest_Digests* release_digests();
+  ::safe_browsing::ClientDownloadRequest_Digests* mutable_digests();
+  void set_allocated_digests(::safe_browsing::ClientDownloadRequest_Digests* digests);
+  private:
+  const ::safe_browsing::ClientDownloadRequest_Digests& _internal_digests() const;
+  ::safe_browsing::ClientDownloadRequest_Digests* _internal_mutable_digests();
+  public:
+  void unsafe_arena_set_allocated_digests(
+      ::safe_browsing::ClientDownloadRequest_Digests* digests);
+  ::safe_browsing::ClientDownloadRequest_Digests* unsafe_arena_release_digests();
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest_SignatureInfo* release_signature();
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* mutable_signature();
+  void set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+  private:
+  const ::safe_browsing::ClientDownloadRequest_SignatureInfo& _internal_signature() const;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* _internal_mutable_signature();
+  public:
+  void unsafe_arena_set_allocated_signature(
+      ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* unsafe_arena_release_signature();
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+  bool has_image_headers() const;
+  private:
+  bool _internal_has_image_headers() const;
+  public:
+  void clear_image_headers();
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest_ImageHeaders* release_image_headers();
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* mutable_image_headers();
+  void set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+  private:
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders& _internal_image_headers() const;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* _internal_mutable_image_headers();
+  public:
+  void unsafe_arena_set_allocated_image_headers(
+      ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* unsafe_arena_release_image_headers();
+
+  // optional int64 length = 4;
+  bool has_length() const;
+  private:
+  bool _internal_has_length() const;
+  public:
+  void clear_length();
+  int64_t length() const;
+  void set_length(int64_t value);
+  private:
+  int64_t _internal_length() const;
+  void _internal_set_length(int64_t value);
+  public:
+
+  // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 2;
+  bool has_download_type() const;
+  private:
+  bool _internal_has_download_type() const;
+  public:
+  void clear_download_type();
+  ::safe_browsing::ClientDownloadRequest_DownloadType download_type() const;
+  void set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value);
+  private:
+  ::safe_browsing::ClientDownloadRequest_DownloadType _internal_download_type() const;
+  void _internal_set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_basename_;
+    ::safe_browsing::ClientDownloadRequest_Digests* digests_;
+    ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature_;
+    ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers_;
+    int64_t length_;
+    int download_type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest) */ {
+ public:
+  inline ClientDownloadRequest() : ClientDownloadRequest(nullptr) {}
+  ~ClientDownloadRequest() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadRequest(const ClientDownloadRequest& from);
+  ClientDownloadRequest(ClientDownloadRequest&& from) noexcept
+    : ClientDownloadRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadRequest& operator=(const ClientDownloadRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadRequest& operator=(ClientDownloadRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadRequest* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadRequest*>(
+               &_ClientDownloadRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    24;
+
+  friend void swap(ClientDownloadRequest& a, ClientDownloadRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadRequest>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadRequest& from);
+  void MergeFrom(const ClientDownloadRequest& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadRequest";
+  }
+  protected:
+  explicit ClientDownloadRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientDownloadRequest_Digests Digests;
+  typedef ClientDownloadRequest_Resource Resource;
+  typedef ClientDownloadRequest_CertificateChain CertificateChain;
+  typedef ClientDownloadRequest_ExtendedAttr ExtendedAttr;
+  typedef ClientDownloadRequest_SignatureInfo SignatureInfo;
+  typedef ClientDownloadRequest_PEImageHeaders PEImageHeaders;
+  typedef ClientDownloadRequest_MachOHeaders MachOHeaders;
+  typedef ClientDownloadRequest_ImageHeaders ImageHeaders;
+  typedef ClientDownloadRequest_ArchivedBinary ArchivedBinary;
+
+  typedef ClientDownloadRequest_ResourceType ResourceType;
+  static constexpr ResourceType DOWNLOAD_URL =
+    ClientDownloadRequest_ResourceType_DOWNLOAD_URL;
+  static constexpr ResourceType DOWNLOAD_REDIRECT =
+    ClientDownloadRequest_ResourceType_DOWNLOAD_REDIRECT;
+  static constexpr ResourceType TAB_URL =
+    ClientDownloadRequest_ResourceType_TAB_URL;
+  static constexpr ResourceType TAB_REDIRECT =
+    ClientDownloadRequest_ResourceType_TAB_REDIRECT;
+  static constexpr ResourceType PPAPI_DOCUMENT =
+    ClientDownloadRequest_ResourceType_PPAPI_DOCUMENT;
+  static constexpr ResourceType PPAPI_PLUGIN =
+    ClientDownloadRequest_ResourceType_PPAPI_PLUGIN;
+  static inline bool ResourceType_IsValid(int value) {
+    return ClientDownloadRequest_ResourceType_IsValid(value);
+  }
+  static constexpr ResourceType ResourceType_MIN =
+    ClientDownloadRequest_ResourceType_ResourceType_MIN;
+  static constexpr ResourceType ResourceType_MAX =
+    ClientDownloadRequest_ResourceType_ResourceType_MAX;
+  static constexpr int ResourceType_ARRAYSIZE =
+    ClientDownloadRequest_ResourceType_ResourceType_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& ResourceType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ResourceType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ResourceType_Name.");
+    return ClientDownloadRequest_ResourceType_Name(enum_t_value);
+  }
+  static inline bool ResourceType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ResourceType* value) {
+    return ClientDownloadRequest_ResourceType_Parse(name, value);
+  }
+
+  typedef ClientDownloadRequest_DownloadType DownloadType;
+  static constexpr DownloadType WIN_EXECUTABLE =
+    ClientDownloadRequest_DownloadType_WIN_EXECUTABLE;
+  static constexpr DownloadType CHROME_EXTENSION =
+    ClientDownloadRequest_DownloadType_CHROME_EXTENSION;
+  static constexpr DownloadType ANDROID_APK =
+    ClientDownloadRequest_DownloadType_ANDROID_APK;
+  static constexpr DownloadType ZIPPED_EXECUTABLE =
+    ClientDownloadRequest_DownloadType_ZIPPED_EXECUTABLE;
+  static constexpr DownloadType MAC_EXECUTABLE =
+    ClientDownloadRequest_DownloadType_MAC_EXECUTABLE;
+  static constexpr DownloadType ZIPPED_ARCHIVE =
+    ClientDownloadRequest_DownloadType_ZIPPED_ARCHIVE;
+  static constexpr DownloadType ARCHIVE =
+    ClientDownloadRequest_DownloadType_ARCHIVE;
+  static constexpr DownloadType INVALID_ZIP =
+    ClientDownloadRequest_DownloadType_INVALID_ZIP;
+  static constexpr DownloadType INVALID_MAC_ARCHIVE =
+    ClientDownloadRequest_DownloadType_INVALID_MAC_ARCHIVE;
+  static constexpr DownloadType PPAPI_SAVE_REQUEST =
+    ClientDownloadRequest_DownloadType_PPAPI_SAVE_REQUEST;
+  static constexpr DownloadType SAMPLED_UNSUPPORTED_FILE =
+    ClientDownloadRequest_DownloadType_SAMPLED_UNSUPPORTED_FILE;
+  static inline bool DownloadType_IsValid(int value) {
+    return ClientDownloadRequest_DownloadType_IsValid(value);
+  }
+  static constexpr DownloadType DownloadType_MIN =
+    ClientDownloadRequest_DownloadType_DownloadType_MIN;
+  static constexpr DownloadType DownloadType_MAX =
+    ClientDownloadRequest_DownloadType_DownloadType_MAX;
+  static constexpr int DownloadType_ARRAYSIZE =
+    ClientDownloadRequest_DownloadType_DownloadType_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& DownloadType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, DownloadType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function DownloadType_Name.");
+    return ClientDownloadRequest_DownloadType_Name(enum_t_value);
+  }
+  static inline bool DownloadType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      DownloadType* value) {
+    return ClientDownloadRequest_DownloadType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kResourcesFieldNumber = 4,
+    kArchivedBinaryFieldNumber = 22,
+    kAlternateExtensionsFieldNumber = 35,
+    kReferrerChainFieldNumber = 36,
+    kUrlFieldNumber = 1,
+    kFileBasenameFieldNumber = 9,
+    kLocaleFieldNumber = 11,
+    kUdifCodeSignatureFieldNumber = 40,
+    kDigestsFieldNumber = 2,
+    kSignatureFieldNumber = 5,
+    kImageHeadersFieldNumber = 18,
+    kPopulationFieldNumber = 24,
+    kLengthFieldNumber = 3,
+    kDownloadTypeFieldNumber = 10,
+    kUserInitiatedFieldNumber = 6,
+    kArchiveValidFieldNumber = 26,
+    kSkippedUrlWhitelistFieldNumber = 28,
+    kSkippedCertificateWhitelistFieldNumber = 31,
+    kDEPRECATEDDownloadAttributionFinchEnabledFieldNumber = 39,
+  };
+  // repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4;
+  int resources_size() const;
+  private:
+  int _internal_resources_size() const;
+  public:
+  void clear_resources();
+  ::safe_browsing::ClientDownloadRequest_Resource* mutable_resources(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource >*
+      mutable_resources();
+  private:
+  const ::safe_browsing::ClientDownloadRequest_Resource& _internal_resources(int index) const;
+  ::safe_browsing::ClientDownloadRequest_Resource* _internal_add_resources();
+  public:
+  const ::safe_browsing::ClientDownloadRequest_Resource& resources(int index) const;
+  ::safe_browsing::ClientDownloadRequest_Resource* add_resources();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource >&
+      resources() const;
+
+  // repeated .safe_browsing.ClientDownloadRequest.ArchivedBinary archived_binary = 22;
+  int archived_binary_size() const;
+  private:
+  int _internal_archived_binary_size() const;
+  public:
+  void clear_archived_binary();
+  ::safe_browsing::ClientDownloadRequest_ArchivedBinary* mutable_archived_binary(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ArchivedBinary >*
+      mutable_archived_binary();
+  private:
+  const ::safe_browsing::ClientDownloadRequest_ArchivedBinary& _internal_archived_binary(int index) const;
+  ::safe_browsing::ClientDownloadRequest_ArchivedBinary* _internal_add_archived_binary();
+  public:
+  const ::safe_browsing::ClientDownloadRequest_ArchivedBinary& archived_binary(int index) const;
+  ::safe_browsing::ClientDownloadRequest_ArchivedBinary* add_archived_binary();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ArchivedBinary >&
+      archived_binary() const;
+
+  // repeated string alternate_extensions = 35;
+  int alternate_extensions_size() const;
+  private:
+  int _internal_alternate_extensions_size() const;
+  public:
+  void clear_alternate_extensions();
+  const std::string& alternate_extensions(int index) const;
+  std::string* mutable_alternate_extensions(int index);
+  void set_alternate_extensions(int index, const std::string& value);
+  void set_alternate_extensions(int index, std::string&& value);
+  void set_alternate_extensions(int index, const char* value);
+  void set_alternate_extensions(int index, const char* value, size_t size);
+  std::string* add_alternate_extensions();
+  void add_alternate_extensions(const std::string& value);
+  void add_alternate_extensions(std::string&& value);
+  void add_alternate_extensions(const char* value);
+  void add_alternate_extensions(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& alternate_extensions() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_alternate_extensions();
+  private:
+  const std::string& _internal_alternate_extensions(int index) const;
+  std::string* _internal_add_alternate_extensions();
+  public:
+
+  // repeated .safe_browsing.ReferrerChainEntry referrer_chain = 36;
+  int referrer_chain_size() const;
+  private:
+  int _internal_referrer_chain_size() const;
+  public:
+  void clear_referrer_chain();
+  ::safe_browsing::ReferrerChainEntry* mutable_referrer_chain(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry >*
+      mutable_referrer_chain();
+  private:
+  const ::safe_browsing::ReferrerChainEntry& _internal_referrer_chain(int index) const;
+  ::safe_browsing::ReferrerChainEntry* _internal_add_referrer_chain();
+  public:
+  const ::safe_browsing::ReferrerChainEntry& referrer_chain(int index) const;
+  ::safe_browsing::ReferrerChainEntry* add_referrer_chain();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry >&
+      referrer_chain() const;
+
+  // required string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string file_basename = 9;
+  bool has_file_basename() const;
+  private:
+  bool _internal_has_file_basename() const;
+  public:
+  void clear_file_basename();
+  const std::string& file_basename() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_file_basename(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_file_basename();
+  PROTOBUF_NODISCARD std::string* release_file_basename();
+  void set_allocated_file_basename(std::string* file_basename);
+  private:
+  const std::string& _internal_file_basename() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_basename(const std::string& value);
+  std::string* _internal_mutable_file_basename();
+  public:
+
+  // optional string locale = 11;
+  bool has_locale() const;
+  private:
+  bool _internal_has_locale() const;
+  public:
+  void clear_locale();
+  const std::string& locale() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_locale(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_locale();
+  PROTOBUF_NODISCARD std::string* release_locale();
+  void set_allocated_locale(std::string* locale);
+  private:
+  const std::string& _internal_locale() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_locale(const std::string& value);
+  std::string* _internal_mutable_locale();
+  public:
+
+  // optional bytes udif_code_signature = 40;
+  bool has_udif_code_signature() const;
+  private:
+  bool _internal_has_udif_code_signature() const;
+  public:
+  void clear_udif_code_signature();
+  const std::string& udif_code_signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_udif_code_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_udif_code_signature();
+  PROTOBUF_NODISCARD std::string* release_udif_code_signature();
+  void set_allocated_udif_code_signature(std::string* udif_code_signature);
+  private:
+  const std::string& _internal_udif_code_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_udif_code_signature(const std::string& value);
+  std::string* _internal_mutable_udif_code_signature();
+  public:
+
+  // required .safe_browsing.ClientDownloadRequest.Digests digests = 2;
+  bool has_digests() const;
+  private:
+  bool _internal_has_digests() const;
+  public:
+  void clear_digests();
+  const ::safe_browsing::ClientDownloadRequest_Digests& digests() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest_Digests* release_digests();
+  ::safe_browsing::ClientDownloadRequest_Digests* mutable_digests();
+  void set_allocated_digests(::safe_browsing::ClientDownloadRequest_Digests* digests);
+  private:
+  const ::safe_browsing::ClientDownloadRequest_Digests& _internal_digests() const;
+  ::safe_browsing::ClientDownloadRequest_Digests* _internal_mutable_digests();
+  public:
+  void unsafe_arena_set_allocated_digests(
+      ::safe_browsing::ClientDownloadRequest_Digests* digests);
+  ::safe_browsing::ClientDownloadRequest_Digests* unsafe_arena_release_digests();
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest_SignatureInfo* release_signature();
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* mutable_signature();
+  void set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+  private:
+  const ::safe_browsing::ClientDownloadRequest_SignatureInfo& _internal_signature() const;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* _internal_mutable_signature();
+  public:
+  void unsafe_arena_set_allocated_signature(
+      ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* unsafe_arena_release_signature();
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 18;
+  bool has_image_headers() const;
+  private:
+  bool _internal_has_image_headers() const;
+  public:
+  void clear_image_headers();
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest_ImageHeaders* release_image_headers();
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* mutable_image_headers();
+  void set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+  private:
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders& _internal_image_headers() const;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* _internal_mutable_image_headers();
+  public:
+  void unsafe_arena_set_allocated_image_headers(
+      ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* unsafe_arena_release_image_headers();
+
+  // optional .safe_browsing.ChromeUserPopulation population = 24;
+  bool has_population() const;
+  private:
+  bool _internal_has_population() const;
+  public:
+  void clear_population();
+  const ::safe_browsing::ChromeUserPopulation& population() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ChromeUserPopulation* release_population();
+  ::safe_browsing::ChromeUserPopulation* mutable_population();
+  void set_allocated_population(::safe_browsing::ChromeUserPopulation* population);
+  private:
+  const ::safe_browsing::ChromeUserPopulation& _internal_population() const;
+  ::safe_browsing::ChromeUserPopulation* _internal_mutable_population();
+  public:
+  void unsafe_arena_set_allocated_population(
+      ::safe_browsing::ChromeUserPopulation* population);
+  ::safe_browsing::ChromeUserPopulation* unsafe_arena_release_population();
+
+  // required int64 length = 3;
+  bool has_length() const;
+  private:
+  bool _internal_has_length() const;
+  public:
+  void clear_length();
+  int64_t length() const;
+  void set_length(int64_t value);
+  private:
+  int64_t _internal_length() const;
+  void _internal_set_length(int64_t value);
+  public:
+
+  // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 10 [default = WIN_EXECUTABLE];
+  bool has_download_type() const;
+  private:
+  bool _internal_has_download_type() const;
+  public:
+  void clear_download_type();
+  ::safe_browsing::ClientDownloadRequest_DownloadType download_type() const;
+  void set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value);
+  private:
+  ::safe_browsing::ClientDownloadRequest_DownloadType _internal_download_type() const;
+  void _internal_set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value);
+  public:
+
+  // optional bool user_initiated = 6;
+  bool has_user_initiated() const;
+  private:
+  bool _internal_has_user_initiated() const;
+  public:
+  void clear_user_initiated();
+  bool user_initiated() const;
+  void set_user_initiated(bool value);
+  private:
+  bool _internal_user_initiated() const;
+  void _internal_set_user_initiated(bool value);
+  public:
+
+  // optional bool archive_valid = 26;
+  bool has_archive_valid() const;
+  private:
+  bool _internal_has_archive_valid() const;
+  public:
+  void clear_archive_valid();
+  bool archive_valid() const;
+  void set_archive_valid(bool value);
+  private:
+  bool _internal_archive_valid() const;
+  void _internal_set_archive_valid(bool value);
+  public:
+
+  // optional bool skipped_url_whitelist = 28;
+  bool has_skipped_url_whitelist() const;
+  private:
+  bool _internal_has_skipped_url_whitelist() const;
+  public:
+  void clear_skipped_url_whitelist();
+  bool skipped_url_whitelist() const;
+  void set_skipped_url_whitelist(bool value);
+  private:
+  bool _internal_skipped_url_whitelist() const;
+  void _internal_set_skipped_url_whitelist(bool value);
+  public:
+
+  // optional bool skipped_certificate_whitelist = 31;
+  bool has_skipped_certificate_whitelist() const;
+  private:
+  bool _internal_has_skipped_certificate_whitelist() const;
+  public:
+  void clear_skipped_certificate_whitelist();
+  bool skipped_certificate_whitelist() const;
+  void set_skipped_certificate_whitelist(bool value);
+  private:
+  bool _internal_skipped_certificate_whitelist() const;
+  void _internal_set_skipped_certificate_whitelist(bool value);
+  public:
+
+  // optional bool DEPRECATED_download_attribution_finch_enabled = 39 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_deprecated_download_attribution_finch_enabled() const;
+  private:
+  bool _internal_has_deprecated_download_attribution_finch_enabled() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_deprecated_download_attribution_finch_enabled();
+  PROTOBUF_DEPRECATED bool deprecated_download_attribution_finch_enabled() const;
+  PROTOBUF_DEPRECATED void set_deprecated_download_attribution_finch_enabled(bool value);
+  private:
+  bool _internal_deprecated_download_attribution_finch_enabled() const;
+  void _internal_set_deprecated_download_attribution_finch_enabled(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest)
+ private:
+  class _Internal;
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource > resources_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ArchivedBinary > archived_binary_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> alternate_extensions_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry > referrer_chain_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_basename_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr locale_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr udif_code_signature_;
+    ::safe_browsing::ClientDownloadRequest_Digests* digests_;
+    ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature_;
+    ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers_;
+    ::safe_browsing::ChromeUserPopulation* population_;
+    int64_t length_;
+    int download_type_;
+    bool user_initiated_;
+    bool archive_valid_;
+    bool skipped_url_whitelist_;
+    bool skipped_certificate_whitelist_;
+    bool deprecated_download_attribution_finch_enabled_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ReferrerChainEntry_ServerRedirect final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ReferrerChainEntry.ServerRedirect) */ {
+ public:
+  inline ReferrerChainEntry_ServerRedirect() : ReferrerChainEntry_ServerRedirect(nullptr) {}
+  ~ReferrerChainEntry_ServerRedirect() override;
+  explicit PROTOBUF_CONSTEXPR ReferrerChainEntry_ServerRedirect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ReferrerChainEntry_ServerRedirect(const ReferrerChainEntry_ServerRedirect& from);
+  ReferrerChainEntry_ServerRedirect(ReferrerChainEntry_ServerRedirect&& from) noexcept
+    : ReferrerChainEntry_ServerRedirect() {
+    *this = ::std::move(from);
+  }
+
+  inline ReferrerChainEntry_ServerRedirect& operator=(const ReferrerChainEntry_ServerRedirect& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ReferrerChainEntry_ServerRedirect& operator=(ReferrerChainEntry_ServerRedirect&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ReferrerChainEntry_ServerRedirect& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ReferrerChainEntry_ServerRedirect* internal_default_instance() {
+    return reinterpret_cast<const ReferrerChainEntry_ServerRedirect*>(
+               &_ReferrerChainEntry_ServerRedirect_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    25;
+
+  friend void swap(ReferrerChainEntry_ServerRedirect& a, ReferrerChainEntry_ServerRedirect& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ReferrerChainEntry_ServerRedirect* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ReferrerChainEntry_ServerRedirect* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ReferrerChainEntry_ServerRedirect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ReferrerChainEntry_ServerRedirect>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ReferrerChainEntry_ServerRedirect& from);
+  void MergeFrom(const ReferrerChainEntry_ServerRedirect& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ReferrerChainEntry_ServerRedirect* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ReferrerChainEntry.ServerRedirect";
+  }
+  protected:
+  explicit ReferrerChainEntry_ServerRedirect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUrlFieldNumber = 1,
+  };
+  // optional string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ReferrerChainEntry.ServerRedirect)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ReferrerChainEntry final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ReferrerChainEntry) */ {
+ public:
+  inline ReferrerChainEntry() : ReferrerChainEntry(nullptr) {}
+  ~ReferrerChainEntry() override;
+  explicit PROTOBUF_CONSTEXPR ReferrerChainEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ReferrerChainEntry(const ReferrerChainEntry& from);
+  ReferrerChainEntry(ReferrerChainEntry&& from) noexcept
+    : ReferrerChainEntry() {
+    *this = ::std::move(from);
+  }
+
+  inline ReferrerChainEntry& operator=(const ReferrerChainEntry& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ReferrerChainEntry& operator=(ReferrerChainEntry&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ReferrerChainEntry& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ReferrerChainEntry* internal_default_instance() {
+    return reinterpret_cast<const ReferrerChainEntry*>(
+               &_ReferrerChainEntry_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    26;
+
+  friend void swap(ReferrerChainEntry& a, ReferrerChainEntry& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ReferrerChainEntry* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ReferrerChainEntry* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ReferrerChainEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ReferrerChainEntry>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ReferrerChainEntry& from);
+  void MergeFrom(const ReferrerChainEntry& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ReferrerChainEntry* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ReferrerChainEntry";
+  }
+  protected:
+  explicit ReferrerChainEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ReferrerChainEntry_ServerRedirect ServerRedirect;
+
+  typedef ReferrerChainEntry_URLType URLType;
+  static constexpr URLType EVENT_URL =
+    ReferrerChainEntry_URLType_EVENT_URL;
+  static constexpr URLType LANDING_PAGE =
+    ReferrerChainEntry_URLType_LANDING_PAGE;
+  static constexpr URLType LANDING_REFERRER =
+    ReferrerChainEntry_URLType_LANDING_REFERRER;
+  static constexpr URLType CLIENT_REDIRECT =
+    ReferrerChainEntry_URLType_CLIENT_REDIRECT;
+  static constexpr URLType DEPRECATED_SERVER_REDIRECT =
+    ReferrerChainEntry_URLType_DEPRECATED_SERVER_REDIRECT;
+  static inline bool URLType_IsValid(int value) {
+    return ReferrerChainEntry_URLType_IsValid(value);
+  }
+  static constexpr URLType URLType_MIN =
+    ReferrerChainEntry_URLType_URLType_MIN;
+  static constexpr URLType URLType_MAX =
+    ReferrerChainEntry_URLType_URLType_MAX;
+  static constexpr int URLType_ARRAYSIZE =
+    ReferrerChainEntry_URLType_URLType_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& URLType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, URLType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function URLType_Name.");
+    return ReferrerChainEntry_URLType_Name(enum_t_value);
+  }
+  static inline bool URLType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      URLType* value) {
+    return ReferrerChainEntry_URLType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIpAddressesFieldNumber = 3,
+    kServerRedirectChainFieldNumber = 8,
+    kUrlFieldNumber = 1,
+    kReferrerUrlFieldNumber = 4,
+    kReferrerMainFrameUrlFieldNumber = 5,
+    kMainFrameUrlFieldNumber = 9,
+    kNavigationTimeMsecFieldNumber = 7,
+    kIsRetargetingFieldNumber = 6,
+    kTypeFieldNumber = 2,
+  };
+  // repeated string ip_addresses = 3;
+  int ip_addresses_size() const;
+  private:
+  int _internal_ip_addresses_size() const;
+  public:
+  void clear_ip_addresses();
+  const std::string& ip_addresses(int index) const;
+  std::string* mutable_ip_addresses(int index);
+  void set_ip_addresses(int index, const std::string& value);
+  void set_ip_addresses(int index, std::string&& value);
+  void set_ip_addresses(int index, const char* value);
+  void set_ip_addresses(int index, const char* value, size_t size);
+  std::string* add_ip_addresses();
+  void add_ip_addresses(const std::string& value);
+  void add_ip_addresses(std::string&& value);
+  void add_ip_addresses(const char* value);
+  void add_ip_addresses(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& ip_addresses() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_ip_addresses();
+  private:
+  const std::string& _internal_ip_addresses(int index) const;
+  std::string* _internal_add_ip_addresses();
+  public:
+
+  // repeated .safe_browsing.ReferrerChainEntry.ServerRedirect server_redirect_chain = 8;
+  int server_redirect_chain_size() const;
+  private:
+  int _internal_server_redirect_chain_size() const;
+  public:
+  void clear_server_redirect_chain();
+  ::safe_browsing::ReferrerChainEntry_ServerRedirect* mutable_server_redirect_chain(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry_ServerRedirect >*
+      mutable_server_redirect_chain();
+  private:
+  const ::safe_browsing::ReferrerChainEntry_ServerRedirect& _internal_server_redirect_chain(int index) const;
+  ::safe_browsing::ReferrerChainEntry_ServerRedirect* _internal_add_server_redirect_chain();
+  public:
+  const ::safe_browsing::ReferrerChainEntry_ServerRedirect& server_redirect_chain(int index) const;
+  ::safe_browsing::ReferrerChainEntry_ServerRedirect* add_server_redirect_chain();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry_ServerRedirect >&
+      server_redirect_chain() const;
+
+  // optional string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string referrer_url = 4;
+  bool has_referrer_url() const;
+  private:
+  bool _internal_has_referrer_url() const;
+  public:
+  void clear_referrer_url();
+  const std::string& referrer_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_referrer_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_referrer_url();
+  PROTOBUF_NODISCARD std::string* release_referrer_url();
+  void set_allocated_referrer_url(std::string* referrer_url);
+  private:
+  const std::string& _internal_referrer_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_referrer_url(const std::string& value);
+  std::string* _internal_mutable_referrer_url();
+  public:
+
+  // optional string referrer_main_frame_url = 5;
+  bool has_referrer_main_frame_url() const;
+  private:
+  bool _internal_has_referrer_main_frame_url() const;
+  public:
+  void clear_referrer_main_frame_url();
+  const std::string& referrer_main_frame_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_referrer_main_frame_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_referrer_main_frame_url();
+  PROTOBUF_NODISCARD std::string* release_referrer_main_frame_url();
+  void set_allocated_referrer_main_frame_url(std::string* referrer_main_frame_url);
+  private:
+  const std::string& _internal_referrer_main_frame_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_referrer_main_frame_url(const std::string& value);
+  std::string* _internal_mutable_referrer_main_frame_url();
+  public:
+
+  // optional string main_frame_url = 9;
+  bool has_main_frame_url() const;
+  private:
+  bool _internal_has_main_frame_url() const;
+  public:
+  void clear_main_frame_url();
+  const std::string& main_frame_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_main_frame_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_main_frame_url();
+  PROTOBUF_NODISCARD std::string* release_main_frame_url();
+  void set_allocated_main_frame_url(std::string* main_frame_url);
+  private:
+  const std::string& _internal_main_frame_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_main_frame_url(const std::string& value);
+  std::string* _internal_mutable_main_frame_url();
+  public:
+
+  // optional double navigation_time_msec = 7;
+  bool has_navigation_time_msec() const;
+  private:
+  bool _internal_has_navigation_time_msec() const;
+  public:
+  void clear_navigation_time_msec();
+  double navigation_time_msec() const;
+  void set_navigation_time_msec(double value);
+  private:
+  double _internal_navigation_time_msec() const;
+  void _internal_set_navigation_time_msec(double value);
+  public:
+
+  // optional bool is_retargeting = 6;
+  bool has_is_retargeting() const;
+  private:
+  bool _internal_has_is_retargeting() const;
+  public:
+  void clear_is_retargeting();
+  bool is_retargeting() const;
+  void set_is_retargeting(bool value);
+  private:
+  bool _internal_is_retargeting() const;
+  void _internal_set_is_retargeting(bool value);
+  public:
+
+  // optional .safe_browsing.ReferrerChainEntry.URLType type = 2 [default = CLIENT_REDIRECT];
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::safe_browsing::ReferrerChainEntry_URLType type() const;
+  void set_type(::safe_browsing::ReferrerChainEntry_URLType value);
+  private:
+  ::safe_browsing::ReferrerChainEntry_URLType _internal_type() const;
+  void _internal_set_type(::safe_browsing::ReferrerChainEntry_URLType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ReferrerChainEntry)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> ip_addresses_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry_ServerRedirect > server_redirect_chain_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr referrer_url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr referrer_main_frame_url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr main_frame_url_;
+    double navigation_time_msec_;
+    bool is_retargeting_;
+    int type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadResponse_MoreInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadResponse.MoreInfo) */ {
+ public:
+  inline ClientDownloadResponse_MoreInfo() : ClientDownloadResponse_MoreInfo(nullptr) {}
+  ~ClientDownloadResponse_MoreInfo() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadResponse_MoreInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadResponse_MoreInfo(const ClientDownloadResponse_MoreInfo& from);
+  ClientDownloadResponse_MoreInfo(ClientDownloadResponse_MoreInfo&& from) noexcept
+    : ClientDownloadResponse_MoreInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadResponse_MoreInfo& operator=(const ClientDownloadResponse_MoreInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadResponse_MoreInfo& operator=(ClientDownloadResponse_MoreInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadResponse_MoreInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadResponse_MoreInfo* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadResponse_MoreInfo*>(
+               &_ClientDownloadResponse_MoreInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    27;
+
+  friend void swap(ClientDownloadResponse_MoreInfo& a, ClientDownloadResponse_MoreInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadResponse_MoreInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadResponse_MoreInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadResponse_MoreInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadResponse_MoreInfo>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadResponse_MoreInfo& from);
+  void MergeFrom(const ClientDownloadResponse_MoreInfo& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadResponse_MoreInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadResponse.MoreInfo";
+  }
+  protected:
+  explicit ClientDownloadResponse_MoreInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDescriptionFieldNumber = 1,
+    kUrlFieldNumber = 2,
+  };
+  // optional string description = 1;
+  bool has_description() const;
+  private:
+  bool _internal_has_description() const;
+  public:
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // optional string url = 2;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadResponse.MoreInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadResponse) */ {
+ public:
+  inline ClientDownloadResponse() : ClientDownloadResponse(nullptr) {}
+  ~ClientDownloadResponse() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadResponse(const ClientDownloadResponse& from);
+  ClientDownloadResponse(ClientDownloadResponse&& from) noexcept
+    : ClientDownloadResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadResponse& operator=(const ClientDownloadResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadResponse& operator=(ClientDownloadResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadResponse* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadResponse*>(
+               &_ClientDownloadResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    28;
+
+  friend void swap(ClientDownloadResponse& a, ClientDownloadResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadResponse* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadResponse>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadResponse& from);
+  void MergeFrom(const ClientDownloadResponse& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadResponse";
+  }
+  protected:
+  explicit ClientDownloadResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientDownloadResponse_MoreInfo MoreInfo;
+
+  typedef ClientDownloadResponse_Verdict Verdict;
+  static constexpr Verdict SAFE =
+    ClientDownloadResponse_Verdict_SAFE;
+  static constexpr Verdict DANGEROUS =
+    ClientDownloadResponse_Verdict_DANGEROUS;
+  static constexpr Verdict UNCOMMON =
+    ClientDownloadResponse_Verdict_UNCOMMON;
+  static constexpr Verdict POTENTIALLY_UNWANTED =
+    ClientDownloadResponse_Verdict_POTENTIALLY_UNWANTED;
+  static constexpr Verdict DANGEROUS_HOST =
+    ClientDownloadResponse_Verdict_DANGEROUS_HOST;
+  static constexpr Verdict UNKNOWN =
+    ClientDownloadResponse_Verdict_UNKNOWN;
+  static inline bool Verdict_IsValid(int value) {
+    return ClientDownloadResponse_Verdict_IsValid(value);
+  }
+  static constexpr Verdict Verdict_MIN =
+    ClientDownloadResponse_Verdict_Verdict_MIN;
+  static constexpr Verdict Verdict_MAX =
+    ClientDownloadResponse_Verdict_Verdict_MAX;
+  static constexpr int Verdict_ARRAYSIZE =
+    ClientDownloadResponse_Verdict_Verdict_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& Verdict_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Verdict>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Verdict_Name.");
+    return ClientDownloadResponse_Verdict_Name(enum_t_value);
+  }
+  static inline bool Verdict_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Verdict* value) {
+    return ClientDownloadResponse_Verdict_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTokenFieldNumber = 3,
+    kMoreInfoFieldNumber = 2,
+    kVerdictFieldNumber = 1,
+    kUploadFieldNumber = 5,
+  };
+  // optional bytes token = 3;
+  bool has_token() const;
+  private:
+  bool _internal_has_token() const;
+  public:
+  void clear_token();
+  const std::string& token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_token();
+  PROTOBUF_NODISCARD std::string* release_token();
+  void set_allocated_token(std::string* token);
+  private:
+  const std::string& _internal_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
+  std::string* _internal_mutable_token();
+  public:
+
+  // optional .safe_browsing.ClientDownloadResponse.MoreInfo more_info = 2;
+  bool has_more_info() const;
+  private:
+  bool _internal_has_more_info() const;
+  public:
+  void clear_more_info();
+  const ::safe_browsing::ClientDownloadResponse_MoreInfo& more_info() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadResponse_MoreInfo* release_more_info();
+  ::safe_browsing::ClientDownloadResponse_MoreInfo* mutable_more_info();
+  void set_allocated_more_info(::safe_browsing::ClientDownloadResponse_MoreInfo* more_info);
+  private:
+  const ::safe_browsing::ClientDownloadResponse_MoreInfo& _internal_more_info() const;
+  ::safe_browsing::ClientDownloadResponse_MoreInfo* _internal_mutable_more_info();
+  public:
+  void unsafe_arena_set_allocated_more_info(
+      ::safe_browsing::ClientDownloadResponse_MoreInfo* more_info);
+  ::safe_browsing::ClientDownloadResponse_MoreInfo* unsafe_arena_release_more_info();
+
+  // optional .safe_browsing.ClientDownloadResponse.Verdict verdict = 1 [default = SAFE];
+  bool has_verdict() const;
+  private:
+  bool _internal_has_verdict() const;
+  public:
+  void clear_verdict();
+  ::safe_browsing::ClientDownloadResponse_Verdict verdict() const;
+  void set_verdict(::safe_browsing::ClientDownloadResponse_Verdict value);
+  private:
+  ::safe_browsing::ClientDownloadResponse_Verdict _internal_verdict() const;
+  void _internal_set_verdict(::safe_browsing::ClientDownloadResponse_Verdict value);
+  public:
+
+  // optional bool upload = 5;
+  bool has_upload() const;
+  private:
+  bool _internal_has_upload() const;
+  public:
+  void clear_upload();
+  bool upload() const;
+  void set_upload(bool value);
+  private:
+  bool _internal_upload() const;
+  void _internal_set_upload(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
+    ::safe_browsing::ClientDownloadResponse_MoreInfo* more_info_;
+    int verdict_;
+    bool upload_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadReport_UserInformation final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadReport.UserInformation) */ {
+ public:
+  inline ClientDownloadReport_UserInformation() : ClientDownloadReport_UserInformation(nullptr) {}
+  ~ClientDownloadReport_UserInformation() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadReport_UserInformation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadReport_UserInformation(const ClientDownloadReport_UserInformation& from);
+  ClientDownloadReport_UserInformation(ClientDownloadReport_UserInformation&& from) noexcept
+    : ClientDownloadReport_UserInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadReport_UserInformation& operator=(const ClientDownloadReport_UserInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadReport_UserInformation& operator=(ClientDownloadReport_UserInformation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadReport_UserInformation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadReport_UserInformation* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadReport_UserInformation*>(
+               &_ClientDownloadReport_UserInformation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    29;
+
+  friend void swap(ClientDownloadReport_UserInformation& a, ClientDownloadReport_UserInformation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadReport_UserInformation* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadReport_UserInformation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadReport_UserInformation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadReport_UserInformation>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadReport_UserInformation& from);
+  void MergeFrom(const ClientDownloadReport_UserInformation& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadReport_UserInformation* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadReport.UserInformation";
+  }
+  protected:
+  explicit ClientDownloadReport_UserInformation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEmailFieldNumber = 1,
+  };
+  // optional string email = 1;
+  bool has_email() const;
+  private:
+  bool _internal_has_email() const;
+  public:
+  void clear_email();
+  const std::string& email() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_email(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_email();
+  PROTOBUF_NODISCARD std::string* release_email();
+  void set_allocated_email(std::string* email);
+  private:
+  const std::string& _internal_email() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_email(const std::string& value);
+  std::string* _internal_mutable_email();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadReport.UserInformation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr email_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadReport final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadReport) */ {
+ public:
+  inline ClientDownloadReport() : ClientDownloadReport(nullptr) {}
+  ~ClientDownloadReport() override;
+  explicit PROTOBUF_CONSTEXPR ClientDownloadReport(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientDownloadReport(const ClientDownloadReport& from);
+  ClientDownloadReport(ClientDownloadReport&& from) noexcept
+    : ClientDownloadReport() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientDownloadReport& operator=(const ClientDownloadReport& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientDownloadReport& operator=(ClientDownloadReport&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientDownloadReport& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientDownloadReport* internal_default_instance() {
+    return reinterpret_cast<const ClientDownloadReport*>(
+               &_ClientDownloadReport_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    30;
+
+  friend void swap(ClientDownloadReport& a, ClientDownloadReport& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientDownloadReport* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientDownloadReport* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadReport* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientDownloadReport>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientDownloadReport& from);
+  void MergeFrom(const ClientDownloadReport& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientDownloadReport* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientDownloadReport";
+  }
+  protected:
+  explicit ClientDownloadReport(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientDownloadReport_UserInformation UserInformation;
+
+  typedef ClientDownloadReport_Reason Reason;
+  static constexpr Reason SHARE =
+    ClientDownloadReport_Reason_SHARE;
+  static constexpr Reason FALSE_POSITIVE =
+    ClientDownloadReport_Reason_FALSE_POSITIVE;
+  static constexpr Reason APPEAL =
+    ClientDownloadReport_Reason_APPEAL;
+  static inline bool Reason_IsValid(int value) {
+    return ClientDownloadReport_Reason_IsValid(value);
+  }
+  static constexpr Reason Reason_MIN =
+    ClientDownloadReport_Reason_Reason_MIN;
+  static constexpr Reason Reason_MAX =
+    ClientDownloadReport_Reason_Reason_MAX;
+  static constexpr int Reason_ARRAYSIZE =
+    ClientDownloadReport_Reason_Reason_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& Reason_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Reason>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Reason_Name.");
+    return ClientDownloadReport_Reason_Name(enum_t_value);
+  }
+  static inline bool Reason_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Reason* value) {
+    return ClientDownloadReport_Reason_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCommentFieldNumber = 4,
+    kDownloadRequestFieldNumber = 2,
+    kUserInformationFieldNumber = 3,
+    kDownloadResponseFieldNumber = 5,
+    kReasonFieldNumber = 1,
+  };
+  // optional bytes comment = 4;
+  bool has_comment() const;
+  private:
+  bool _internal_has_comment() const;
+  public:
+  void clear_comment();
+  const std::string& comment() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_comment(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_comment();
+  PROTOBUF_NODISCARD std::string* release_comment();
+  void set_allocated_comment(std::string* comment);
+  private:
+  const std::string& _internal_comment() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_comment(const std::string& value);
+  std::string* _internal_mutable_comment();
+  public:
+
+  // optional .safe_browsing.ClientDownloadRequest download_request = 2;
+  bool has_download_request() const;
+  private:
+  bool _internal_has_download_request() const;
+  public:
+  void clear_download_request();
+  const ::safe_browsing::ClientDownloadRequest& download_request() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest* release_download_request();
+  ::safe_browsing::ClientDownloadRequest* mutable_download_request();
+  void set_allocated_download_request(::safe_browsing::ClientDownloadRequest* download_request);
+  private:
+  const ::safe_browsing::ClientDownloadRequest& _internal_download_request() const;
+  ::safe_browsing::ClientDownloadRequest* _internal_mutable_download_request();
+  public:
+  void unsafe_arena_set_allocated_download_request(
+      ::safe_browsing::ClientDownloadRequest* download_request);
+  ::safe_browsing::ClientDownloadRequest* unsafe_arena_release_download_request();
+
+  // optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3;
+  bool has_user_information() const;
+  private:
+  bool _internal_has_user_information() const;
+  public:
+  void clear_user_information();
+  const ::safe_browsing::ClientDownloadReport_UserInformation& user_information() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadReport_UserInformation* release_user_information();
+  ::safe_browsing::ClientDownloadReport_UserInformation* mutable_user_information();
+  void set_allocated_user_information(::safe_browsing::ClientDownloadReport_UserInformation* user_information);
+  private:
+  const ::safe_browsing::ClientDownloadReport_UserInformation& _internal_user_information() const;
+  ::safe_browsing::ClientDownloadReport_UserInformation* _internal_mutable_user_information();
+  public:
+  void unsafe_arena_set_allocated_user_information(
+      ::safe_browsing::ClientDownloadReport_UserInformation* user_information);
+  ::safe_browsing::ClientDownloadReport_UserInformation* unsafe_arena_release_user_information();
+
+  // optional .safe_browsing.ClientDownloadResponse download_response = 5;
+  bool has_download_response() const;
+  private:
+  bool _internal_has_download_response() const;
+  public:
+  void clear_download_response();
+  const ::safe_browsing::ClientDownloadResponse& download_response() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadResponse* release_download_response();
+  ::safe_browsing::ClientDownloadResponse* mutable_download_response();
+  void set_allocated_download_response(::safe_browsing::ClientDownloadResponse* download_response);
+  private:
+  const ::safe_browsing::ClientDownloadResponse& _internal_download_response() const;
+  ::safe_browsing::ClientDownloadResponse* _internal_mutable_download_response();
+  public:
+  void unsafe_arena_set_allocated_download_response(
+      ::safe_browsing::ClientDownloadResponse* download_response);
+  ::safe_browsing::ClientDownloadResponse* unsafe_arena_release_download_response();
+
+  // optional .safe_browsing.ClientDownloadReport.Reason reason = 1;
+  bool has_reason() const;
+  private:
+  bool _internal_has_reason() const;
+  public:
+  void clear_reason();
+  ::safe_browsing::ClientDownloadReport_Reason reason() const;
+  void set_reason(::safe_browsing::ClientDownloadReport_Reason value);
+  private:
+  ::safe_browsing::ClientDownloadReport_Reason _internal_reason() const;
+  void _internal_set_reason(::safe_browsing::ClientDownloadReport_Reason value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadReport)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_;
+    ::safe_browsing::ClientDownloadRequest* download_request_;
+    ::safe_browsing::ClientDownloadReport_UserInformation* user_information_;
+    ::safe_browsing::ClientDownloadResponse* download_response_;
+    int reason_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientUploadResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientUploadResponse) */ {
+ public:
+  inline ClientUploadResponse() : ClientUploadResponse(nullptr) {}
+  ~ClientUploadResponse() override;
+  explicit PROTOBUF_CONSTEXPR ClientUploadResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientUploadResponse(const ClientUploadResponse& from);
+  ClientUploadResponse(ClientUploadResponse&& from) noexcept
+    : ClientUploadResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientUploadResponse& operator=(const ClientUploadResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientUploadResponse& operator=(ClientUploadResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientUploadResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientUploadResponse* internal_default_instance() {
+    return reinterpret_cast<const ClientUploadResponse*>(
+               &_ClientUploadResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    31;
+
+  friend void swap(ClientUploadResponse& a, ClientUploadResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientUploadResponse* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientUploadResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientUploadResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientUploadResponse>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientUploadResponse& from);
+  void MergeFrom(const ClientUploadResponse& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientUploadResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientUploadResponse";
+  }
+  protected:
+  explicit ClientUploadResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientUploadResponse_UploadStatus UploadStatus;
+  static constexpr UploadStatus SUCCESS =
+    ClientUploadResponse_UploadStatus_SUCCESS;
+  static constexpr UploadStatus UPLOAD_FAILURE =
+    ClientUploadResponse_UploadStatus_UPLOAD_FAILURE;
+  static inline bool UploadStatus_IsValid(int value) {
+    return ClientUploadResponse_UploadStatus_IsValid(value);
+  }
+  static constexpr UploadStatus UploadStatus_MIN =
+    ClientUploadResponse_UploadStatus_UploadStatus_MIN;
+  static constexpr UploadStatus UploadStatus_MAX =
+    ClientUploadResponse_UploadStatus_UploadStatus_MAX;
+  static constexpr int UploadStatus_ARRAYSIZE =
+    ClientUploadResponse_UploadStatus_UploadStatus_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& UploadStatus_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, UploadStatus>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function UploadStatus_Name.");
+    return ClientUploadResponse_UploadStatus_Name(enum_t_value);
+  }
+  static inline bool UploadStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      UploadStatus* value) {
+    return ClientUploadResponse_UploadStatus_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPermalinkFieldNumber = 2,
+    kStatusFieldNumber = 1,
+  };
+  // optional string permalink = 2;
+  bool has_permalink() const;
+  private:
+  bool _internal_has_permalink() const;
+  public:
+  void clear_permalink();
+  const std::string& permalink() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_permalink(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_permalink();
+  PROTOBUF_NODISCARD std::string* release_permalink();
+  void set_allocated_permalink(std::string* permalink);
+  private:
+  const std::string& _internal_permalink() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_permalink(const std::string& value);
+  std::string* _internal_mutable_permalink();
+  public:
+
+  // optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1;
+  bool has_status() const;
+  private:
+  bool _internal_has_status() const;
+  public:
+  void clear_status();
+  ::safe_browsing::ClientUploadResponse_UploadStatus status() const;
+  void set_status(::safe_browsing::ClientUploadResponse_UploadStatus value);
+  private:
+  ::safe_browsing::ClientUploadResponse_UploadStatus _internal_status() const;
+  void _internal_set_status(::safe_browsing::ClientUploadResponse_UploadStatus value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientUploadResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr permalink_;
+    int status_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_IncidentData_TrackedPreferenceIncident final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident) */ {
+ public:
+  inline ClientIncidentReport_IncidentData_TrackedPreferenceIncident() : ClientIncidentReport_IncidentData_TrackedPreferenceIncident(nullptr) {}
+  ~ClientIncidentReport_IncidentData_TrackedPreferenceIncident() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData_TrackedPreferenceIncident(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from);
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident(ClientIncidentReport_IncidentData_TrackedPreferenceIncident&& from) noexcept
+    : ClientIncidentReport_IncidentData_TrackedPreferenceIncident() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_IncidentData_TrackedPreferenceIncident& operator=(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_IncidentData_TrackedPreferenceIncident& operator=(ClientIncidentReport_IncidentData_TrackedPreferenceIncident&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_IncidentData_TrackedPreferenceIncident* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_IncidentData_TrackedPreferenceIncident*>(
+               &_ClientIncidentReport_IncidentData_TrackedPreferenceIncident_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    32;
+
+  friend void swap(ClientIncidentReport_IncidentData_TrackedPreferenceIncident& a, ClientIncidentReport_IncidentData_TrackedPreferenceIncident& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_IncidentData_TrackedPreferenceIncident* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_IncidentData_TrackedPreferenceIncident* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_IncidentData_TrackedPreferenceIncident>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from);
+  void MergeFrom(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_IncidentData_TrackedPreferenceIncident* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident";
+  }
+  protected:
+  explicit ClientIncidentReport_IncidentData_TrackedPreferenceIncident(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ValueState;
+  static constexpr ValueState UNKNOWN =
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_UNKNOWN;
+  static constexpr ValueState CLEARED =
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_CLEARED;
+  static constexpr ValueState WEAK_LEGACY_OBSOLETE =
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_WEAK_LEGACY_OBSOLETE;
+  static constexpr ValueState CHANGED =
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_CHANGED;
+  static constexpr ValueState UNTRUSTED_UNKNOWN_VALUE =
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_UNTRUSTED_UNKNOWN_VALUE;
+  static constexpr ValueState BYPASS_CLEARED =
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_BYPASS_CLEARED;
+  static constexpr ValueState BYPASS_CHANGED =
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_BYPASS_CHANGED;
+  static inline bool ValueState_IsValid(int value) {
+    return ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_IsValid(value);
+  }
+  static constexpr ValueState ValueState_MIN =
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_MIN;
+  static constexpr ValueState ValueState_MAX =
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_MAX;
+  static constexpr int ValueState_ARRAYSIZE =
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& ValueState_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ValueState>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ValueState_Name.");
+    return ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_Name(enum_t_value);
+  }
+  static inline bool ValueState_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ValueState* value) {
+    return ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSplitKeyFieldNumber = 3,
+    kPathFieldNumber = 1,
+    kAtomicValueFieldNumber = 2,
+    kValueStateFieldNumber = 4,
+  };
+  // repeated string split_key = 3;
+  int split_key_size() const;
+  private:
+  int _internal_split_key_size() const;
+  public:
+  void clear_split_key();
+  const std::string& split_key(int index) const;
+  std::string* mutable_split_key(int index);
+  void set_split_key(int index, const std::string& value);
+  void set_split_key(int index, std::string&& value);
+  void set_split_key(int index, const char* value);
+  void set_split_key(int index, const char* value, size_t size);
+  std::string* add_split_key();
+  void add_split_key(const std::string& value);
+  void add_split_key(std::string&& value);
+  void add_split_key(const char* value);
+  void add_split_key(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& split_key() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_split_key();
+  private:
+  const std::string& _internal_split_key(int index) const;
+  std::string* _internal_add_split_key();
+  public:
+
+  // optional string path = 1;
+  bool has_path() const;
+  private:
+  bool _internal_has_path() const;
+  public:
+  void clear_path();
+  const std::string& path() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_path(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_path();
+  PROTOBUF_NODISCARD std::string* release_path();
+  void set_allocated_path(std::string* path);
+  private:
+  const std::string& _internal_path() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_path(const std::string& value);
+  std::string* _internal_mutable_path();
+  public:
+
+  // optional string atomic_value = 2;
+  bool has_atomic_value() const;
+  private:
+  bool _internal_has_atomic_value() const;
+  public:
+  void clear_atomic_value();
+  const std::string& atomic_value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_atomic_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_atomic_value();
+  PROTOBUF_NODISCARD std::string* release_atomic_value();
+  void set_allocated_atomic_value(std::string* atomic_value);
+  private:
+  const std::string& _internal_atomic_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_atomic_value(const std::string& value);
+  std::string* _internal_mutable_atomic_value();
+  public:
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.ValueState value_state = 4;
+  bool has_value_state() const;
+  private:
+  bool _internal_has_value_state() const;
+  public:
+  void clear_value_state();
+  ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState value_state() const;
+  void set_value_state(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState value);
+  private:
+  ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState _internal_value_state() const;
+  void _internal_set_value_state(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> split_key_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr path_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr atomic_value_;
+    int value_state_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile) */ {
+ public:
+  inline ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile() : ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile(nullptr) {}
+  ~ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from);
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile&& from) noexcept
+    : ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& operator=(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& operator=(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile*>(
+               &_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    33;
+
+  friend void swap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& a, ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from);
+  void MergeFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile";
+  }
+  protected:
+  explicit ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRelativePathFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kImageHeadersFieldNumber = 3,
+  };
+  // optional string relative_path = 1;
+  bool has_relative_path() const;
+  private:
+  bool _internal_has_relative_path() const;
+  public:
+  void clear_relative_path();
+  const std::string& relative_path() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_relative_path(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_relative_path();
+  PROTOBUF_NODISCARD std::string* release_relative_path();
+  void set_allocated_relative_path(std::string* relative_path);
+  private:
+  const std::string& _internal_relative_path() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_relative_path(const std::string& value);
+  std::string* _internal_mutable_relative_path();
+  public:
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest_SignatureInfo* release_signature();
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* mutable_signature();
+  void set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+  private:
+  const ::safe_browsing::ClientDownloadRequest_SignatureInfo& _internal_signature() const;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* _internal_mutable_signature();
+  public:
+  void unsafe_arena_set_allocated_signature(
+      ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* unsafe_arena_release_signature();
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+  bool has_image_headers() const;
+  private:
+  bool _internal_has_image_headers() const;
+  public:
+  void clear_image_headers();
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest_ImageHeaders* release_image_headers();
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* mutable_image_headers();
+  void set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+  private:
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders& _internal_image_headers() const;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* _internal_mutable_image_headers();
+  public:
+  void unsafe_arena_set_allocated_image_headers(
+      ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* unsafe_arena_release_image_headers();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr relative_path_;
+    ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature_;
+    ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_IncidentData_BinaryIntegrityIncident final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident) */ {
+ public:
+  inline ClientIncidentReport_IncidentData_BinaryIntegrityIncident() : ClientIncidentReport_IncidentData_BinaryIntegrityIncident(nullptr) {}
+  ~ClientIncidentReport_IncidentData_BinaryIntegrityIncident() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData_BinaryIntegrityIncident(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from);
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident(ClientIncidentReport_IncidentData_BinaryIntegrityIncident&& from) noexcept
+    : ClientIncidentReport_IncidentData_BinaryIntegrityIncident() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_IncidentData_BinaryIntegrityIncident& operator=(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_IncidentData_BinaryIntegrityIncident& operator=(ClientIncidentReport_IncidentData_BinaryIntegrityIncident&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_IncidentData_BinaryIntegrityIncident* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_IncidentData_BinaryIntegrityIncident*>(
+               &_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    34;
+
+  friend void swap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident& a, ClientIncidentReport_IncidentData_BinaryIntegrityIncident& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_IncidentData_BinaryIntegrityIncident>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from);
+  void MergeFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident";
+  }
+  protected:
+  explicit ClientIncidentReport_IncidentData_BinaryIntegrityIncident(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile ContainedFile;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kContainedFileFieldNumber = 5,
+    kFileBasenameFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kImageHeadersFieldNumber = 3,
+    kSecErrorFieldNumber = 4,
+  };
+  // repeated .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile contained_file = 5;
+  int contained_file_size() const;
+  private:
+  int _internal_contained_file_size() const;
+  public:
+  void clear_contained_file();
+  ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* mutable_contained_file(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile >*
+      mutable_contained_file();
+  private:
+  const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& _internal_contained_file(int index) const;
+  ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* _internal_add_contained_file();
+  public:
+  const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& contained_file(int index) const;
+  ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* add_contained_file();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile >&
+      contained_file() const;
+
+  // optional string file_basename = 1;
+  bool has_file_basename() const;
+  private:
+  bool _internal_has_file_basename() const;
+  public:
+  void clear_file_basename();
+  const std::string& file_basename() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_file_basename(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_file_basename();
+  PROTOBUF_NODISCARD std::string* release_file_basename();
+  void set_allocated_file_basename(std::string* file_basename);
+  private:
+  const std::string& _internal_file_basename() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_basename(const std::string& value);
+  std::string* _internal_mutable_file_basename();
+  public:
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest_SignatureInfo* release_signature();
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* mutable_signature();
+  void set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+  private:
+  const ::safe_browsing::ClientDownloadRequest_SignatureInfo& _internal_signature() const;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* _internal_mutable_signature();
+  public:
+  void unsafe_arena_set_allocated_signature(
+      ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* unsafe_arena_release_signature();
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+  bool has_image_headers() const;
+  private:
+  bool _internal_has_image_headers() const;
+  public:
+  void clear_image_headers();
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest_ImageHeaders* release_image_headers();
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* mutable_image_headers();
+  void set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+  private:
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders& _internal_image_headers() const;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* _internal_mutable_image_headers();
+  public:
+  void unsafe_arena_set_allocated_image_headers(
+      ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* unsafe_arena_release_image_headers();
+
+  // optional int32 sec_error = 4;
+  bool has_sec_error() const;
+  private:
+  bool _internal_has_sec_error() const;
+  public:
+  void clear_sec_error();
+  int32_t sec_error() const;
+  void set_sec_error(int32_t value);
+  private:
+  int32_t _internal_sec_error() const;
+  void _internal_set_sec_error(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile > contained_file_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_basename_;
+    ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature_;
+    ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers_;
+    int32_t sec_error_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_IncidentData_ResourceRequestIncident final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident) */ {
+ public:
+  inline ClientIncidentReport_IncidentData_ResourceRequestIncident() : ClientIncidentReport_IncidentData_ResourceRequestIncident(nullptr) {}
+  ~ClientIncidentReport_IncidentData_ResourceRequestIncident() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData_ResourceRequestIncident(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_IncidentData_ResourceRequestIncident(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from);
+  ClientIncidentReport_IncidentData_ResourceRequestIncident(ClientIncidentReport_IncidentData_ResourceRequestIncident&& from) noexcept
+    : ClientIncidentReport_IncidentData_ResourceRequestIncident() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_IncidentData_ResourceRequestIncident& operator=(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_IncidentData_ResourceRequestIncident& operator=(ClientIncidentReport_IncidentData_ResourceRequestIncident&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_IncidentData_ResourceRequestIncident& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_IncidentData_ResourceRequestIncident* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_IncidentData_ResourceRequestIncident*>(
+               &_ClientIncidentReport_IncidentData_ResourceRequestIncident_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    35;
+
+  friend void swap(ClientIncidentReport_IncidentData_ResourceRequestIncident& a, ClientIncidentReport_IncidentData_ResourceRequestIncident& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_IncidentData_ResourceRequestIncident* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_IncidentData_ResourceRequestIncident* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_IncidentData_ResourceRequestIncident* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_IncidentData_ResourceRequestIncident>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from);
+  void MergeFrom(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_IncidentData_ResourceRequestIncident* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident";
+  }
+  protected:
+  explicit ClientIncidentReport_IncidentData_ResourceRequestIncident(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_IncidentData_ResourceRequestIncident_Type Type;
+  static constexpr Type UNKNOWN =
+    ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_UNKNOWN;
+  static constexpr Type TYPE_PATTERN =
+    ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_TYPE_PATTERN;
+  static inline bool Type_IsValid(int value) {
+    return ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_IsValid(value);
+  }
+  static constexpr Type Type_MIN =
+    ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_MIN;
+  static constexpr Type Type_MAX =
+    ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_MAX;
+  static constexpr int Type_ARRAYSIZE =
+    ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& Type_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Type>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Type_Name.");
+    return ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Name(enum_t_value);
+  }
+  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Type* value) {
+    return ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDigestFieldNumber = 1,
+    kOriginFieldNumber = 2,
+    kTypeFieldNumber = 3,
+  };
+  // optional bytes digest = 1;
+  bool has_digest() const;
+  private:
+  bool _internal_has_digest() const;
+  public:
+  void clear_digest();
+  const std::string& digest() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_digest(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_digest();
+  PROTOBUF_NODISCARD std::string* release_digest();
+  void set_allocated_digest(std::string* digest);
+  private:
+  const std::string& _internal_digest() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_digest(const std::string& value);
+  std::string* _internal_mutable_digest();
+  public:
+
+  // optional string origin = 2;
+  bool has_origin() const;
+  private:
+  bool _internal_has_origin() const;
+  public:
+  void clear_origin();
+  const std::string& origin() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_origin(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_origin();
+  PROTOBUF_NODISCARD std::string* release_origin();
+  void set_allocated_origin(std::string* origin);
+  private:
+  const std::string& _internal_origin() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_origin(const std::string& value);
+  std::string* _internal_mutable_origin();
+  public:
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.Type type = 3 [default = UNKNOWN];
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type type() const;
+  void set_type(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type value);
+  private:
+  ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type _internal_type() const;
+  void _internal_set_type(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr digest_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr origin_;
+    int type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_IncidentData final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.IncidentData) */ {
+ public:
+  inline ClientIncidentReport_IncidentData() : ClientIncidentReport_IncidentData(nullptr) {}
+  ~ClientIncidentReport_IncidentData() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_IncidentData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_IncidentData(const ClientIncidentReport_IncidentData& from);
+  ClientIncidentReport_IncidentData(ClientIncidentReport_IncidentData&& from) noexcept
+    : ClientIncidentReport_IncidentData() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_IncidentData& operator=(const ClientIncidentReport_IncidentData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_IncidentData& operator=(ClientIncidentReport_IncidentData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_IncidentData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_IncidentData* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_IncidentData*>(
+               &_ClientIncidentReport_IncidentData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    36;
+
+  friend void swap(ClientIncidentReport_IncidentData& a, ClientIncidentReport_IncidentData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_IncidentData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_IncidentData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_IncidentData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_IncidentData>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_IncidentData& from);
+  void MergeFrom(const ClientIncidentReport_IncidentData& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_IncidentData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.IncidentData";
+  }
+  protected:
+  explicit ClientIncidentReport_IncidentData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_IncidentData_TrackedPreferenceIncident TrackedPreferenceIncident;
+  typedef ClientIncidentReport_IncidentData_BinaryIntegrityIncident BinaryIntegrityIncident;
+  typedef ClientIncidentReport_IncidentData_ResourceRequestIncident ResourceRequestIncident;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTrackedPreferenceFieldNumber = 2,
+    kBinaryIntegrityFieldNumber = 3,
+    kResourceRequestFieldNumber = 7,
+    kIncidentTimeMsecFieldNumber = 1,
+  };
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident tracked_preference = 2;
+  bool has_tracked_preference() const;
+  private:
+  bool _internal_has_tracked_preference() const;
+  public:
+  void clear_tracked_preference();
+  const ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident& tracked_preference() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* release_tracked_preference();
+  ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* mutable_tracked_preference();
+  void set_allocated_tracked_preference(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* tracked_preference);
+  private:
+  const ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident& _internal_tracked_preference() const;
+  ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* _internal_mutable_tracked_preference();
+  public:
+  void unsafe_arena_set_allocated_tracked_preference(
+      ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* tracked_preference);
+  ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* unsafe_arena_release_tracked_preference();
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident binary_integrity = 3;
+  bool has_binary_integrity() const;
+  private:
+  bool _internal_has_binary_integrity() const;
+  public:
+  void clear_binary_integrity();
+  const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident& binary_integrity() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* release_binary_integrity();
+  ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* mutable_binary_integrity();
+  void set_allocated_binary_integrity(::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* binary_integrity);
+  private:
+  const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident& _internal_binary_integrity() const;
+  ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* _internal_mutable_binary_integrity();
+  public:
+  void unsafe_arena_set_allocated_binary_integrity(
+      ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* binary_integrity);
+  ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* unsafe_arena_release_binary_integrity();
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident resource_request = 7;
+  bool has_resource_request() const;
+  private:
+  bool _internal_has_resource_request() const;
+  public:
+  void clear_resource_request();
+  const ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident& resource_request() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* release_resource_request();
+  ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* mutable_resource_request();
+  void set_allocated_resource_request(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* resource_request);
+  private:
+  const ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident& _internal_resource_request() const;
+  ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* _internal_mutable_resource_request();
+  public:
+  void unsafe_arena_set_allocated_resource_request(
+      ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* resource_request);
+  ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* unsafe_arena_release_resource_request();
+
+  // optional int64 incident_time_msec = 1;
+  bool has_incident_time_msec() const;
+  private:
+  bool _internal_has_incident_time_msec() const;
+  public:
+  void clear_incident_time_msec();
+  int64_t incident_time_msec() const;
+  void set_incident_time_msec(int64_t value);
+  private:
+  int64_t _internal_incident_time_msec() const;
+  void _internal_set_incident_time_msec(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* tracked_preference_;
+    ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* binary_integrity_;
+    ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* resource_request_;
+    int64_t incident_time_msec_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_DownloadDetails final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.DownloadDetails) */ {
+ public:
+  inline ClientIncidentReport_DownloadDetails() : ClientIncidentReport_DownloadDetails(nullptr) {}
+  ~ClientIncidentReport_DownloadDetails() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_DownloadDetails(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_DownloadDetails(const ClientIncidentReport_DownloadDetails& from);
+  ClientIncidentReport_DownloadDetails(ClientIncidentReport_DownloadDetails&& from) noexcept
+    : ClientIncidentReport_DownloadDetails() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_DownloadDetails& operator=(const ClientIncidentReport_DownloadDetails& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_DownloadDetails& operator=(ClientIncidentReport_DownloadDetails&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_DownloadDetails& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_DownloadDetails* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_DownloadDetails*>(
+               &_ClientIncidentReport_DownloadDetails_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    37;
+
+  friend void swap(ClientIncidentReport_DownloadDetails& a, ClientIncidentReport_DownloadDetails& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_DownloadDetails* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_DownloadDetails* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_DownloadDetails* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_DownloadDetails>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_DownloadDetails& from);
+  void MergeFrom(const ClientIncidentReport_DownloadDetails& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_DownloadDetails* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.DownloadDetails";
+  }
+  protected:
+  explicit ClientIncidentReport_DownloadDetails(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTokenFieldNumber = 1,
+    kDownloadFieldNumber = 2,
+    kDownloadTimeMsecFieldNumber = 3,
+    kOpenTimeMsecFieldNumber = 4,
+  };
+  // optional bytes token = 1;
+  bool has_token() const;
+  private:
+  bool _internal_has_token() const;
+  public:
+  void clear_token();
+  const std::string& token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_token();
+  PROTOBUF_NODISCARD std::string* release_token();
+  void set_allocated_token(std::string* token);
+  private:
+  const std::string& _internal_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
+  std::string* _internal_mutable_token();
+  public:
+
+  // optional .safe_browsing.ClientDownloadRequest download = 2;
+  bool has_download() const;
+  private:
+  bool _internal_has_download() const;
+  public:
+  void clear_download();
+  const ::safe_browsing::ClientDownloadRequest& download() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest* release_download();
+  ::safe_browsing::ClientDownloadRequest* mutable_download();
+  void set_allocated_download(::safe_browsing::ClientDownloadRequest* download);
+  private:
+  const ::safe_browsing::ClientDownloadRequest& _internal_download() const;
+  ::safe_browsing::ClientDownloadRequest* _internal_mutable_download();
+  public:
+  void unsafe_arena_set_allocated_download(
+      ::safe_browsing::ClientDownloadRequest* download);
+  ::safe_browsing::ClientDownloadRequest* unsafe_arena_release_download();
+
+  // optional int64 download_time_msec = 3;
+  bool has_download_time_msec() const;
+  private:
+  bool _internal_has_download_time_msec() const;
+  public:
+  void clear_download_time_msec();
+  int64_t download_time_msec() const;
+  void set_download_time_msec(int64_t value);
+  private:
+  int64_t _internal_download_time_msec() const;
+  void _internal_set_download_time_msec(int64_t value);
+  public:
+
+  // optional int64 open_time_msec = 4;
+  bool has_open_time_msec() const;
+  private:
+  bool _internal_has_open_time_msec() const;
+  public:
+  void clear_open_time_msec();
+  int64_t open_time_msec() const;
+  void set_open_time_msec(int64_t value);
+  private:
+  int64_t _internal_open_time_msec() const;
+  void _internal_set_open_time_msec(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.DownloadDetails)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
+    ::safe_browsing::ClientDownloadRequest* download_;
+    int64_t download_time_msec_;
+    int64_t open_time_msec_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_OS_RegistryValue final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue) */ {
+ public:
+  inline ClientIncidentReport_EnvironmentData_OS_RegistryValue() : ClientIncidentReport_EnvironmentData_OS_RegistryValue(nullptr) {}
+  ~ClientIncidentReport_EnvironmentData_OS_RegistryValue() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_OS_RegistryValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_EnvironmentData_OS_RegistryValue(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from);
+  ClientIncidentReport_EnvironmentData_OS_RegistryValue(ClientIncidentReport_EnvironmentData_OS_RegistryValue&& from) noexcept
+    : ClientIncidentReport_EnvironmentData_OS_RegistryValue() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_EnvironmentData_OS_RegistryValue& operator=(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_EnvironmentData_OS_RegistryValue& operator=(ClientIncidentReport_EnvironmentData_OS_RegistryValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_EnvironmentData_OS_RegistryValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_EnvironmentData_OS_RegistryValue* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_EnvironmentData_OS_RegistryValue*>(
+               &_ClientIncidentReport_EnvironmentData_OS_RegistryValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    38;
+
+  friend void swap(ClientIncidentReport_EnvironmentData_OS_RegistryValue& a, ClientIncidentReport_EnvironmentData_OS_RegistryValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_EnvironmentData_OS_RegistryValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_EnvironmentData_OS_RegistryValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_OS_RegistryValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_OS_RegistryValue>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_EnvironmentData_OS_RegistryValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue";
+  }
+  protected:
+  explicit ClientIncidentReport_EnvironmentData_OS_RegistryValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kDataFieldNumber = 3,
+    kTypeFieldNumber = 2,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional bytes data = 3;
+  bool has_data() const;
+  private:
+  bool _internal_has_data() const;
+  public:
+  void clear_data();
+  const std::string& data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_data();
+  PROTOBUF_NODISCARD std::string* release_data();
+  void set_allocated_data(std::string* data);
+  private:
+  const std::string& _internal_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
+  std::string* _internal_mutable_data();
+  public:
+
+  // optional uint32 type = 2;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  uint32_t type() const;
+  void set_type(uint32_t value);
+  private:
+  uint32_t _internal_type() const;
+  void _internal_set_type(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
+    uint32_t type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_OS_RegistryKey final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey) */ {
+ public:
+  inline ClientIncidentReport_EnvironmentData_OS_RegistryKey() : ClientIncidentReport_EnvironmentData_OS_RegistryKey(nullptr) {}
+  ~ClientIncidentReport_EnvironmentData_OS_RegistryKey() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_OS_RegistryKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_EnvironmentData_OS_RegistryKey(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from);
+  ClientIncidentReport_EnvironmentData_OS_RegistryKey(ClientIncidentReport_EnvironmentData_OS_RegistryKey&& from) noexcept
+    : ClientIncidentReport_EnvironmentData_OS_RegistryKey() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_EnvironmentData_OS_RegistryKey& operator=(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_EnvironmentData_OS_RegistryKey& operator=(ClientIncidentReport_EnvironmentData_OS_RegistryKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_EnvironmentData_OS_RegistryKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_EnvironmentData_OS_RegistryKey* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_EnvironmentData_OS_RegistryKey*>(
+               &_ClientIncidentReport_EnvironmentData_OS_RegistryKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    39;
+
+  friend void swap(ClientIncidentReport_EnvironmentData_OS_RegistryKey& a, ClientIncidentReport_EnvironmentData_OS_RegistryKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_EnvironmentData_OS_RegistryKey* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_EnvironmentData_OS_RegistryKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_OS_RegistryKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_OS_RegistryKey>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_EnvironmentData_OS_RegistryKey* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey";
+  }
+  protected:
+  explicit ClientIncidentReport_EnvironmentData_OS_RegistryKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 2,
+    kKeyFieldNumber = 3,
+    kNameFieldNumber = 1,
+  };
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue value = 2;
+  int value_size() const;
+  private:
+  int _internal_value_size() const;
+  public:
+  void clear_value();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue* mutable_value(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue >*
+      mutable_value();
+  private:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue& _internal_value(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue* _internal_add_value();
+  public:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue& value(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue* add_value();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue >&
+      value() const;
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey key = 3;
+  int key_size() const;
+  private:
+  int _internal_key_size() const;
+  public:
+  void clear_key();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* mutable_key(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >*
+      mutable_key();
+  private:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey& _internal_key(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* _internal_add_key();
+  public:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey& key(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* add_key();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >&
+      key() const;
+
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue > value_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey > key_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_OS final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.OS) */ {
+ public:
+  inline ClientIncidentReport_EnvironmentData_OS() : ClientIncidentReport_EnvironmentData_OS(nullptr) {}
+  ~ClientIncidentReport_EnvironmentData_OS() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_OS(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_EnvironmentData_OS(const ClientIncidentReport_EnvironmentData_OS& from);
+  ClientIncidentReport_EnvironmentData_OS(ClientIncidentReport_EnvironmentData_OS&& from) noexcept
+    : ClientIncidentReport_EnvironmentData_OS() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_EnvironmentData_OS& operator=(const ClientIncidentReport_EnvironmentData_OS& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_EnvironmentData_OS& operator=(ClientIncidentReport_EnvironmentData_OS&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_EnvironmentData_OS& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_EnvironmentData_OS* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_EnvironmentData_OS*>(
+               &_ClientIncidentReport_EnvironmentData_OS_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    40;
+
+  friend void swap(ClientIncidentReport_EnvironmentData_OS& a, ClientIncidentReport_EnvironmentData_OS& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_EnvironmentData_OS* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_EnvironmentData_OS* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_OS* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_OS>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_OS& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_OS& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_EnvironmentData_OS* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.EnvironmentData.OS";
+  }
+  protected:
+  explicit ClientIncidentReport_EnvironmentData_OS(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_EnvironmentData_OS_RegistryValue RegistryValue;
+  typedef ClientIncidentReport_EnvironmentData_OS_RegistryKey RegistryKey;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRegistryKeyFieldNumber = 3,
+    kOsNameFieldNumber = 1,
+    kOsVersionFieldNumber = 2,
+    kIsEnrolledToDomainFieldNumber = 4,
+  };
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey registry_key = 3;
+  int registry_key_size() const;
+  private:
+  int _internal_registry_key_size() const;
+  public:
+  void clear_registry_key();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* mutable_registry_key(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >*
+      mutable_registry_key();
+  private:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey& _internal_registry_key(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* _internal_add_registry_key();
+  public:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey& registry_key(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* add_registry_key();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >&
+      registry_key() const;
+
+  // optional string os_name = 1;
+  bool has_os_name() const;
+  private:
+  bool _internal_has_os_name() const;
+  public:
+  void clear_os_name();
+  const std::string& os_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_os_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_os_name();
+  PROTOBUF_NODISCARD std::string* release_os_name();
+  void set_allocated_os_name(std::string* os_name);
+  private:
+  const std::string& _internal_os_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_os_name(const std::string& value);
+  std::string* _internal_mutable_os_name();
+  public:
+
+  // optional string os_version = 2;
+  bool has_os_version() const;
+  private:
+  bool _internal_has_os_version() const;
+  public:
+  void clear_os_version();
+  const std::string& os_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_os_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_os_version();
+  PROTOBUF_NODISCARD std::string* release_os_version();
+  void set_allocated_os_version(std::string* os_version);
+  private:
+  const std::string& _internal_os_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_os_version(const std::string& value);
+  std::string* _internal_mutable_os_version();
+  public:
+
+  // optional bool is_enrolled_to_domain = 4;
+  bool has_is_enrolled_to_domain() const;
+  private:
+  bool _internal_has_is_enrolled_to_domain() const;
+  public:
+  void clear_is_enrolled_to_domain();
+  bool is_enrolled_to_domain() const;
+  void set_is_enrolled_to_domain(bool value);
+  private:
+  bool _internal_is_enrolled_to_domain() const;
+  void _internal_set_is_enrolled_to_domain(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey > registry_key_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr os_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr os_version_;
+    bool is_enrolled_to_domain_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Machine final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Machine) */ {
+ public:
+  inline ClientIncidentReport_EnvironmentData_Machine() : ClientIncidentReport_EnvironmentData_Machine(nullptr) {}
+  ~ClientIncidentReport_EnvironmentData_Machine() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Machine(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_EnvironmentData_Machine(const ClientIncidentReport_EnvironmentData_Machine& from);
+  ClientIncidentReport_EnvironmentData_Machine(ClientIncidentReport_EnvironmentData_Machine&& from) noexcept
+    : ClientIncidentReport_EnvironmentData_Machine() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_EnvironmentData_Machine& operator=(const ClientIncidentReport_EnvironmentData_Machine& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_EnvironmentData_Machine& operator=(ClientIncidentReport_EnvironmentData_Machine&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Machine& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_EnvironmentData_Machine* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_EnvironmentData_Machine*>(
+               &_ClientIncidentReport_EnvironmentData_Machine_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    41;
+
+  friend void swap(ClientIncidentReport_EnvironmentData_Machine& a, ClientIncidentReport_EnvironmentData_Machine& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_EnvironmentData_Machine* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_EnvironmentData_Machine* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Machine* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Machine>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Machine& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Machine& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_EnvironmentData_Machine* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.EnvironmentData.Machine";
+  }
+  protected:
+  explicit ClientIncidentReport_EnvironmentData_Machine(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCpuArchitectureFieldNumber = 1,
+    kCpuVendorFieldNumber = 2,
+    kCpuidFieldNumber = 3,
+  };
+  // optional string cpu_architecture = 1;
+  bool has_cpu_architecture() const;
+  private:
+  bool _internal_has_cpu_architecture() const;
+  public:
+  void clear_cpu_architecture();
+  const std::string& cpu_architecture() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_cpu_architecture(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_cpu_architecture();
+  PROTOBUF_NODISCARD std::string* release_cpu_architecture();
+  void set_allocated_cpu_architecture(std::string* cpu_architecture);
+  private:
+  const std::string& _internal_cpu_architecture() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cpu_architecture(const std::string& value);
+  std::string* _internal_mutable_cpu_architecture();
+  public:
+
+  // optional string cpu_vendor = 2;
+  bool has_cpu_vendor() const;
+  private:
+  bool _internal_has_cpu_vendor() const;
+  public:
+  void clear_cpu_vendor();
+  const std::string& cpu_vendor() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_cpu_vendor(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_cpu_vendor();
+  PROTOBUF_NODISCARD std::string* release_cpu_vendor();
+  void set_allocated_cpu_vendor(std::string* cpu_vendor);
+  private:
+  const std::string& _internal_cpu_vendor() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cpu_vendor(const std::string& value);
+  std::string* _internal_mutable_cpu_vendor();
+  public:
+
+  // optional uint32 cpuid = 3;
+  bool has_cpuid() const;
+  private:
+  bool _internal_has_cpuid() const;
+  public:
+  void clear_cpuid();
+  uint32_t cpuid() const;
+  void set_cpuid(uint32_t value);
+  private:
+  uint32_t _internal_cpuid() const;
+  void _internal_set_cpuid(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cpu_architecture_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cpu_vendor_;
+    uint32_t cpuid_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Process_Patch final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch) */ {
+ public:
+  inline ClientIncidentReport_EnvironmentData_Process_Patch() : ClientIncidentReport_EnvironmentData_Process_Patch(nullptr) {}
+  ~ClientIncidentReport_EnvironmentData_Process_Patch() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_Patch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_EnvironmentData_Process_Patch(const ClientIncidentReport_EnvironmentData_Process_Patch& from);
+  ClientIncidentReport_EnvironmentData_Process_Patch(ClientIncidentReport_EnvironmentData_Process_Patch&& from) noexcept
+    : ClientIncidentReport_EnvironmentData_Process_Patch() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_EnvironmentData_Process_Patch& operator=(const ClientIncidentReport_EnvironmentData_Process_Patch& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_EnvironmentData_Process_Patch& operator=(ClientIncidentReport_EnvironmentData_Process_Patch&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Process_Patch& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_EnvironmentData_Process_Patch* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_EnvironmentData_Process_Patch*>(
+               &_ClientIncidentReport_EnvironmentData_Process_Patch_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    42;
+
+  friend void swap(ClientIncidentReport_EnvironmentData_Process_Patch& a, ClientIncidentReport_EnvironmentData_Process_Patch& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_EnvironmentData_Process_Patch* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_EnvironmentData_Process_Patch* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Process_Patch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Process_Patch>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Process_Patch& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Process_Patch& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_EnvironmentData_Process_Patch* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch";
+  }
+  protected:
+  explicit ClientIncidentReport_EnvironmentData_Process_Patch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFunctionFieldNumber = 1,
+    kTargetDllFieldNumber = 2,
+  };
+  // optional string function = 1;
+  bool has_function() const;
+  private:
+  bool _internal_has_function() const;
+  public:
+  void clear_function();
+  const std::string& function() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_function(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_function();
+  PROTOBUF_NODISCARD std::string* release_function();
+  void set_allocated_function(std::string* function);
+  private:
+  const std::string& _internal_function() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_function(const std::string& value);
+  std::string* _internal_mutable_function();
+  public:
+
+  // optional string target_dll = 2;
+  bool has_target_dll() const;
+  private:
+  bool _internal_has_target_dll() const;
+  public:
+  void clear_target_dll();
+  const std::string& target_dll() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_target_dll(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_target_dll();
+  PROTOBUF_NODISCARD std::string* release_target_dll();
+  void set_allocated_target_dll(std::string* target_dll);
+  private:
+  const std::string& _internal_target_dll() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_target_dll(const std::string& value);
+  std::string* _internal_mutable_target_dll();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr function_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr target_dll_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Process_NetworkProvider final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider) */ {
+ public:
+  inline ClientIncidentReport_EnvironmentData_Process_NetworkProvider() : ClientIncidentReport_EnvironmentData_Process_NetworkProvider(nullptr) {}
+  ~ClientIncidentReport_EnvironmentData_Process_NetworkProvider() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_NetworkProvider(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_EnvironmentData_Process_NetworkProvider(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from);
+  ClientIncidentReport_EnvironmentData_Process_NetworkProvider(ClientIncidentReport_EnvironmentData_Process_NetworkProvider&& from) noexcept
+    : ClientIncidentReport_EnvironmentData_Process_NetworkProvider() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_EnvironmentData_Process_NetworkProvider& operator=(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_EnvironmentData_Process_NetworkProvider& operator=(ClientIncidentReport_EnvironmentData_Process_NetworkProvider&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_EnvironmentData_Process_NetworkProvider* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_EnvironmentData_Process_NetworkProvider*>(
+               &_ClientIncidentReport_EnvironmentData_Process_NetworkProvider_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    43;
+
+  friend void swap(ClientIncidentReport_EnvironmentData_Process_NetworkProvider& a, ClientIncidentReport_EnvironmentData_Process_NetworkProvider& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_EnvironmentData_Process_NetworkProvider* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_EnvironmentData_Process_NetworkProvider* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Process_NetworkProvider* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Process_NetworkProvider>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_EnvironmentData_Process_NetworkProvider* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider";
+  }
+  protected:
+  explicit ClientIncidentReport_EnvironmentData_Process_NetworkProvider(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Process_Dll final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll) */ {
+ public:
+  inline ClientIncidentReport_EnvironmentData_Process_Dll() : ClientIncidentReport_EnvironmentData_Process_Dll(nullptr) {}
+  ~ClientIncidentReport_EnvironmentData_Process_Dll() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_Dll(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_EnvironmentData_Process_Dll(const ClientIncidentReport_EnvironmentData_Process_Dll& from);
+  ClientIncidentReport_EnvironmentData_Process_Dll(ClientIncidentReport_EnvironmentData_Process_Dll&& from) noexcept
+    : ClientIncidentReport_EnvironmentData_Process_Dll() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_EnvironmentData_Process_Dll& operator=(const ClientIncidentReport_EnvironmentData_Process_Dll& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_EnvironmentData_Process_Dll& operator=(ClientIncidentReport_EnvironmentData_Process_Dll&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Process_Dll& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_EnvironmentData_Process_Dll* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_EnvironmentData_Process_Dll*>(
+               &_ClientIncidentReport_EnvironmentData_Process_Dll_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    44;
+
+  friend void swap(ClientIncidentReport_EnvironmentData_Process_Dll& a, ClientIncidentReport_EnvironmentData_Process_Dll& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_EnvironmentData_Process_Dll* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_EnvironmentData_Process_Dll* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Process_Dll* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Process_Dll>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Process_Dll& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Process_Dll& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_EnvironmentData_Process_Dll* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll";
+  }
+  protected:
+  explicit ClientIncidentReport_EnvironmentData_Process_Dll(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_EnvironmentData_Process_Dll_Feature Feature;
+  static constexpr Feature UNKNOWN =
+    ClientIncidentReport_EnvironmentData_Process_Dll_Feature_UNKNOWN;
+  static constexpr Feature LSP =
+    ClientIncidentReport_EnvironmentData_Process_Dll_Feature_LSP;
+  static inline bool Feature_IsValid(int value) {
+    return ClientIncidentReport_EnvironmentData_Process_Dll_Feature_IsValid(value);
+  }
+  static constexpr Feature Feature_MIN =
+    ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_MIN;
+  static constexpr Feature Feature_MAX =
+    ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_MAX;
+  static constexpr int Feature_ARRAYSIZE =
+    ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& Feature_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Feature>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Feature_Name.");
+    return ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Name(enum_t_value);
+  }
+  static inline bool Feature_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Feature* value) {
+    return ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFeatureFieldNumber = 4,
+    kPathFieldNumber = 1,
+    kImageHeadersFieldNumber = 5,
+    kBaseAddressFieldNumber = 2,
+    kLengthFieldNumber = 3,
+  };
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.Feature feature = 4;
+  int feature_size() const;
+  private:
+  int _internal_feature_size() const;
+  public:
+  void clear_feature();
+  private:
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature _internal_feature(int index) const;
+  void _internal_add_feature(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_feature();
+  public:
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature feature(int index) const;
+  void set_feature(int index, ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature value);
+  void add_feature(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& feature() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_feature();
+
+  // optional string path = 1;
+  bool has_path() const;
+  private:
+  bool _internal_has_path() const;
+  public:
+  void clear_path();
+  const std::string& path() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_path(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_path();
+  PROTOBUF_NODISCARD std::string* release_path();
+  void set_allocated_path(std::string* path);
+  private:
+  const std::string& _internal_path() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_path(const std::string& value);
+  std::string* _internal_mutable_path();
+  public:
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+  bool has_image_headers() const;
+  private:
+  bool _internal_has_image_headers() const;
+  public:
+  void clear_image_headers();
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientDownloadRequest_ImageHeaders* release_image_headers();
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* mutable_image_headers();
+  void set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+  private:
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders& _internal_image_headers() const;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* _internal_mutable_image_headers();
+  public:
+  void unsafe_arena_set_allocated_image_headers(
+      ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* unsafe_arena_release_image_headers();
+
+  // optional uint64 base_address = 2;
+  bool has_base_address() const;
+  private:
+  bool _internal_has_base_address() const;
+  public:
+  void clear_base_address();
+  uint64_t base_address() const;
+  void set_base_address(uint64_t value);
+  private:
+  uint64_t _internal_base_address() const;
+  void _internal_set_base_address(uint64_t value);
+  public:
+
+  // optional uint32 length = 3;
+  bool has_length() const;
+  private:
+  bool _internal_has_length() const;
+  public:
+  void clear_length();
+  uint32_t length() const;
+  void set_length(uint32_t value);
+  private:
+  uint32_t _internal_length() const;
+  void _internal_set_length(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> feature_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr path_;
+    ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers_;
+    uint64_t base_address_;
+    uint32_t length_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification) */ {
+ public:
+  inline ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification() : ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification(nullptr) {}
+  ~ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from);
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification(ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification&& from) noexcept
+    : ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& operator=(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& operator=(ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification*>(
+               &_ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    45;
+
+  friend void swap(ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& a, ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification";
+  }
+  protected:
+  explicit ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kModifiedBytesFieldNumber = 3,
+    kExportNameFieldNumber = 4,
+    kFileOffsetFieldNumber = 1,
+    kByteCountFieldNumber = 2,
+  };
+  // optional bytes modified_bytes = 3;
+  bool has_modified_bytes() const;
+  private:
+  bool _internal_has_modified_bytes() const;
+  public:
+  void clear_modified_bytes();
+  const std::string& modified_bytes() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_modified_bytes(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_modified_bytes();
+  PROTOBUF_NODISCARD std::string* release_modified_bytes();
+  void set_allocated_modified_bytes(std::string* modified_bytes);
+  private:
+  const std::string& _internal_modified_bytes() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_modified_bytes(const std::string& value);
+  std::string* _internal_mutable_modified_bytes();
+  public:
+
+  // optional string export_name = 4;
+  bool has_export_name() const;
+  private:
+  bool _internal_has_export_name() const;
+  public:
+  void clear_export_name();
+  const std::string& export_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_export_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_export_name();
+  PROTOBUF_NODISCARD std::string* release_export_name();
+  void set_allocated_export_name(std::string* export_name);
+  private:
+  const std::string& _internal_export_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_export_name(const std::string& value);
+  std::string* _internal_mutable_export_name();
+  public:
+
+  // optional uint32 file_offset = 1;
+  bool has_file_offset() const;
+  private:
+  bool _internal_has_file_offset() const;
+  public:
+  void clear_file_offset();
+  uint32_t file_offset() const;
+  void set_file_offset(uint32_t value);
+  private:
+  uint32_t _internal_file_offset() const;
+  void _internal_set_file_offset(uint32_t value);
+  public:
+
+  // optional int32 byte_count = 2;
+  bool has_byte_count() const;
+  private:
+  bool _internal_has_byte_count() const;
+  public:
+  void clear_byte_count();
+  int32_t byte_count() const;
+  void set_byte_count(int32_t value);
+  private:
+  int32_t _internal_byte_count() const;
+  void _internal_set_byte_count(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr modified_bytes_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr export_name_;
+    uint32_t file_offset_;
+    int32_t byte_count_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Process_ModuleState final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState) */ {
+ public:
+  inline ClientIncidentReport_EnvironmentData_Process_ModuleState() : ClientIncidentReport_EnvironmentData_Process_ModuleState(nullptr) {}
+  ~ClientIncidentReport_EnvironmentData_Process_ModuleState() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process_ModuleState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_EnvironmentData_Process_ModuleState(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from);
+  ClientIncidentReport_EnvironmentData_Process_ModuleState(ClientIncidentReport_EnvironmentData_Process_ModuleState&& from) noexcept
+    : ClientIncidentReport_EnvironmentData_Process_ModuleState() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_EnvironmentData_Process_ModuleState& operator=(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_EnvironmentData_Process_ModuleState& operator=(ClientIncidentReport_EnvironmentData_Process_ModuleState&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Process_ModuleState& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_EnvironmentData_Process_ModuleState* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_EnvironmentData_Process_ModuleState*>(
+               &_ClientIncidentReport_EnvironmentData_Process_ModuleState_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    46;
+
+  friend void swap(ClientIncidentReport_EnvironmentData_Process_ModuleState& a, ClientIncidentReport_EnvironmentData_Process_ModuleState& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_EnvironmentData_Process_ModuleState* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_EnvironmentData_Process_ModuleState* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Process_ModuleState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Process_ModuleState>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_EnvironmentData_Process_ModuleState* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState";
+  }
+  protected:
+  explicit ClientIncidentReport_EnvironmentData_Process_ModuleState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification Modification;
+
+  typedef ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ModifiedState;
+  static constexpr ModifiedState UNKNOWN =
+    ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_UNKNOWN;
+  static constexpr ModifiedState MODULE_STATE_UNKNOWN =
+    ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_MODULE_STATE_UNKNOWN;
+  static constexpr ModifiedState MODULE_STATE_UNMODIFIED =
+    ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_MODULE_STATE_UNMODIFIED;
+  static constexpr ModifiedState MODULE_STATE_MODIFIED =
+    ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_MODULE_STATE_MODIFIED;
+  static inline bool ModifiedState_IsValid(int value) {
+    return ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_IsValid(value);
+  }
+  static constexpr ModifiedState ModifiedState_MIN =
+    ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_MIN;
+  static constexpr ModifiedState ModifiedState_MAX =
+    ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_MAX;
+  static constexpr int ModifiedState_ARRAYSIZE =
+    ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& ModifiedState_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ModifiedState>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ModifiedState_Name.");
+    return ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_Name(enum_t_value);
+  }
+  static inline bool ModifiedState_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ModifiedState* value) {
+    return ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOBSOLETEModifiedExportFieldNumber = 3,
+    kModificationFieldNumber = 4,
+    kNameFieldNumber = 1,
+    kModifiedStateFieldNumber = 2,
+  };
+  // repeated string OBSOLETE_modified_export = 3;
+  int obsolete_modified_export_size() const;
+  private:
+  int _internal_obsolete_modified_export_size() const;
+  public:
+  void clear_obsolete_modified_export();
+  const std::string& obsolete_modified_export(int index) const;
+  std::string* mutable_obsolete_modified_export(int index);
+  void set_obsolete_modified_export(int index, const std::string& value);
+  void set_obsolete_modified_export(int index, std::string&& value);
+  void set_obsolete_modified_export(int index, const char* value);
+  void set_obsolete_modified_export(int index, const char* value, size_t size);
+  std::string* add_obsolete_modified_export();
+  void add_obsolete_modified_export(const std::string& value);
+  void add_obsolete_modified_export(std::string&& value);
+  void add_obsolete_modified_export(const char* value);
+  void add_obsolete_modified_export(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& obsolete_modified_export() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_obsolete_modified_export();
+  private:
+  const std::string& _internal_obsolete_modified_export(int index) const;
+  std::string* _internal_add_obsolete_modified_export();
+  public:
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification modification = 4;
+  int modification_size() const;
+  private:
+  int _internal_modification_size() const;
+  public:
+  void clear_modification();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* mutable_modification(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification >*
+      mutable_modification();
+  private:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& _internal_modification(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* _internal_add_modification();
+  public:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& modification(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* add_modification();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification >&
+      modification() const;
+
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.ModifiedState modified_state = 2;
+  bool has_modified_state() const;
+  private:
+  bool _internal_has_modified_state() const;
+  public:
+  void clear_modified_state();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState modified_state() const;
+  void set_modified_state(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState value);
+  private:
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState _internal_modified_state() const;
+  void _internal_set_modified_state(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> obsolete_modified_export_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification > modification_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    int modified_state_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Process final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Process) */ {
+ public:
+  inline ClientIncidentReport_EnvironmentData_Process() : ClientIncidentReport_EnvironmentData_Process(nullptr) {}
+  ~ClientIncidentReport_EnvironmentData_Process() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData_Process(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_EnvironmentData_Process(const ClientIncidentReport_EnvironmentData_Process& from);
+  ClientIncidentReport_EnvironmentData_Process(ClientIncidentReport_EnvironmentData_Process&& from) noexcept
+    : ClientIncidentReport_EnvironmentData_Process() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_EnvironmentData_Process& operator=(const ClientIncidentReport_EnvironmentData_Process& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_EnvironmentData_Process& operator=(ClientIncidentReport_EnvironmentData_Process&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Process& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_EnvironmentData_Process* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_EnvironmentData_Process*>(
+               &_ClientIncidentReport_EnvironmentData_Process_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    47;
+
+  friend void swap(ClientIncidentReport_EnvironmentData_Process& a, ClientIncidentReport_EnvironmentData_Process& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_EnvironmentData_Process* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_EnvironmentData_Process* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Process* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Process>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Process& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Process& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_EnvironmentData_Process* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.EnvironmentData.Process";
+  }
+  protected:
+  explicit ClientIncidentReport_EnvironmentData_Process(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_EnvironmentData_Process_Patch Patch;
+  typedef ClientIncidentReport_EnvironmentData_Process_NetworkProvider NetworkProvider;
+  typedef ClientIncidentReport_EnvironmentData_Process_Dll Dll;
+  typedef ClientIncidentReport_EnvironmentData_Process_ModuleState ModuleState;
+
+  typedef ClientIncidentReport_EnvironmentData_Process_Channel Channel;
+  static constexpr Channel CHANNEL_UNKNOWN =
+    ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_UNKNOWN;
+  static constexpr Channel CHANNEL_CANARY =
+    ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_CANARY;
+  static constexpr Channel CHANNEL_DEV =
+    ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_DEV;
+  static constexpr Channel CHANNEL_BETA =
+    ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_BETA;
+  static constexpr Channel CHANNEL_STABLE =
+    ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_STABLE;
+  static inline bool Channel_IsValid(int value) {
+    return ClientIncidentReport_EnvironmentData_Process_Channel_IsValid(value);
+  }
+  static constexpr Channel Channel_MIN =
+    ClientIncidentReport_EnvironmentData_Process_Channel_Channel_MIN;
+  static constexpr Channel Channel_MAX =
+    ClientIncidentReport_EnvironmentData_Process_Channel_Channel_MAX;
+  static constexpr int Channel_ARRAYSIZE =
+    ClientIncidentReport_EnvironmentData_Process_Channel_Channel_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& Channel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Channel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Channel_Name.");
+    return ClientIncidentReport_EnvironmentData_Process_Channel_Name(enum_t_value);
+  }
+  static inline bool Channel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Channel* value) {
+    return ClientIncidentReport_EnvironmentData_Process_Channel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOBSOLETEDllsFieldNumber = 2,
+    kPatchesFieldNumber = 3,
+    kNetworkProvidersFieldNumber = 4,
+    kDllFieldNumber = 9,
+    kBlacklistedDllFieldNumber = 10,
+    kModuleStateFieldNumber = 11,
+    kVersionFieldNumber = 1,
+    kUptimeMsecFieldNumber = 6,
+    kChromeUpdateChannelFieldNumber = 5,
+    kMetricsConsentFieldNumber = 7,
+    kOBSOLETEExtendedConsentFieldNumber = 8,
+    kOBSOLETEFieldTrialParticipantFieldNumber = 12,
+  };
+  // repeated string OBSOLETE_dlls = 2;
+  int obsolete_dlls_size() const;
+  private:
+  int _internal_obsolete_dlls_size() const;
+  public:
+  void clear_obsolete_dlls();
+  const std::string& obsolete_dlls(int index) const;
+  std::string* mutable_obsolete_dlls(int index);
+  void set_obsolete_dlls(int index, const std::string& value);
+  void set_obsolete_dlls(int index, std::string&& value);
+  void set_obsolete_dlls(int index, const char* value);
+  void set_obsolete_dlls(int index, const char* value, size_t size);
+  std::string* add_obsolete_dlls();
+  void add_obsolete_dlls(const std::string& value);
+  void add_obsolete_dlls(std::string&& value);
+  void add_obsolete_dlls(const char* value);
+  void add_obsolete_dlls(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& obsolete_dlls() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_obsolete_dlls();
+  private:
+  const std::string& _internal_obsolete_dlls(int index) const;
+  std::string* _internal_add_obsolete_dlls();
+  public:
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch patches = 3;
+  int patches_size() const;
+  private:
+  int _internal_patches_size() const;
+  public:
+  void clear_patches();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch* mutable_patches(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch >*
+      mutable_patches();
+  private:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch& _internal_patches(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch* _internal_add_patches();
+  public:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch& patches(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch* add_patches();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch >&
+      patches() const;
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider network_providers = 4;
+  int network_providers_size() const;
+  private:
+  int _internal_network_providers_size() const;
+  public:
+  void clear_network_providers();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider* mutable_network_providers(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider >*
+      mutable_network_providers();
+  private:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider& _internal_network_providers(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider* _internal_add_network_providers();
+  public:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider& network_providers(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider* add_network_providers();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider >&
+      network_providers() const;
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll dll = 9;
+  int dll_size() const;
+  private:
+  int _internal_dll_size() const;
+  public:
+  void clear_dll();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll* mutable_dll(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll >*
+      mutable_dll();
+  private:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll& _internal_dll(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll* _internal_add_dll();
+  public:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll& dll(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll* add_dll();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll >&
+      dll() const;
+
+  // repeated string blacklisted_dll = 10;
+  int blacklisted_dll_size() const;
+  private:
+  int _internal_blacklisted_dll_size() const;
+  public:
+  void clear_blacklisted_dll();
+  const std::string& blacklisted_dll(int index) const;
+  std::string* mutable_blacklisted_dll(int index);
+  void set_blacklisted_dll(int index, const std::string& value);
+  void set_blacklisted_dll(int index, std::string&& value);
+  void set_blacklisted_dll(int index, const char* value);
+  void set_blacklisted_dll(int index, const char* value, size_t size);
+  std::string* add_blacklisted_dll();
+  void add_blacklisted_dll(const std::string& value);
+  void add_blacklisted_dll(std::string&& value);
+  void add_blacklisted_dll(const char* value);
+  void add_blacklisted_dll(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& blacklisted_dll() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_blacklisted_dll();
+  private:
+  const std::string& _internal_blacklisted_dll(int index) const;
+  std::string* _internal_add_blacklisted_dll();
+  public:
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState module_state = 11;
+  int module_state_size() const;
+  private:
+  int _internal_module_state_size() const;
+  public:
+  void clear_module_state();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState* mutable_module_state(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState >*
+      mutable_module_state();
+  private:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState& _internal_module_state(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState* _internal_add_module_state();
+  public:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState& module_state(int index) const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState* add_module_state();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState >&
+      module_state() const;
+
+  // optional string version = 1;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  const std::string& version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_version();
+  PROTOBUF_NODISCARD std::string* release_version();
+  void set_allocated_version(std::string* version);
+  private:
+  const std::string& _internal_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
+  std::string* _internal_mutable_version();
+  public:
+
+  // optional int64 uptime_msec = 6;
+  bool has_uptime_msec() const;
+  private:
+  bool _internal_has_uptime_msec() const;
+  public:
+  void clear_uptime_msec();
+  int64_t uptime_msec() const;
+  void set_uptime_msec(int64_t value);
+  private:
+  int64_t _internal_uptime_msec() const;
+  void _internal_set_uptime_msec(int64_t value);
+  public:
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Channel chrome_update_channel = 5;
+  bool has_chrome_update_channel() const;
+  private:
+  bool _internal_has_chrome_update_channel() const;
+  public:
+  void clear_chrome_update_channel();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel chrome_update_channel() const;
+  void set_chrome_update_channel(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel value);
+  private:
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel _internal_chrome_update_channel() const;
+  void _internal_set_chrome_update_channel(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel value);
+  public:
+
+  // optional bool metrics_consent = 7;
+  bool has_metrics_consent() const;
+  private:
+  bool _internal_has_metrics_consent() const;
+  public:
+  void clear_metrics_consent();
+  bool metrics_consent() const;
+  void set_metrics_consent(bool value);
+  private:
+  bool _internal_metrics_consent() const;
+  void _internal_set_metrics_consent(bool value);
+  public:
+
+  // optional bool OBSOLETE_extended_consent = 8;
+  bool has_obsolete_extended_consent() const;
+  private:
+  bool _internal_has_obsolete_extended_consent() const;
+  public:
+  void clear_obsolete_extended_consent();
+  bool obsolete_extended_consent() const;
+  void set_obsolete_extended_consent(bool value);
+  private:
+  bool _internal_obsolete_extended_consent() const;
+  void _internal_set_obsolete_extended_consent(bool value);
+  public:
+
+  // optional bool OBSOLETE_field_trial_participant = 12;
+  bool has_obsolete_field_trial_participant() const;
+  private:
+  bool _internal_has_obsolete_field_trial_participant() const;
+  public:
+  void clear_obsolete_field_trial_participant();
+  bool obsolete_field_trial_participant() const;
+  void set_obsolete_field_trial_participant(bool value);
+  private:
+  bool _internal_obsolete_field_trial_participant() const;
+  void _internal_set_obsolete_field_trial_participant(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> obsolete_dlls_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch > patches_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider > network_providers_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll > dll_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> blacklisted_dll_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState > module_state_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
+    int64_t uptime_msec_;
+    int chrome_update_channel_;
+    bool metrics_consent_;
+    bool obsolete_extended_consent_;
+    bool obsolete_field_trial_participant_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData) */ {
+ public:
+  inline ClientIncidentReport_EnvironmentData() : ClientIncidentReport_EnvironmentData(nullptr) {}
+  ~ClientIncidentReport_EnvironmentData() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_EnvironmentData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_EnvironmentData(const ClientIncidentReport_EnvironmentData& from);
+  ClientIncidentReport_EnvironmentData(ClientIncidentReport_EnvironmentData&& from) noexcept
+    : ClientIncidentReport_EnvironmentData() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_EnvironmentData& operator=(const ClientIncidentReport_EnvironmentData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_EnvironmentData& operator=(ClientIncidentReport_EnvironmentData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_EnvironmentData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_EnvironmentData* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_EnvironmentData*>(
+               &_ClientIncidentReport_EnvironmentData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    48;
+
+  friend void swap(ClientIncidentReport_EnvironmentData& a, ClientIncidentReport_EnvironmentData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_EnvironmentData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_EnvironmentData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_EnvironmentData>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_EnvironmentData& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_EnvironmentData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.EnvironmentData";
+  }
+  protected:
+  explicit ClientIncidentReport_EnvironmentData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_EnvironmentData_OS OS;
+  typedef ClientIncidentReport_EnvironmentData_Machine Machine;
+  typedef ClientIncidentReport_EnvironmentData_Process Process;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOsFieldNumber = 1,
+    kMachineFieldNumber = 2,
+    kProcessFieldNumber = 3,
+  };
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.OS os = 1;
+  bool has_os() const;
+  private:
+  bool _internal_has_os() const;
+  public:
+  void clear_os();
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS& os() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* release_os();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* mutable_os();
+  void set_allocated_os(::safe_browsing::ClientIncidentReport_EnvironmentData_OS* os);
+  private:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS& _internal_os() const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* _internal_mutable_os();
+  public:
+  void unsafe_arena_set_allocated_os(
+      ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* os);
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* unsafe_arena_release_os();
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Machine machine = 2;
+  bool has_machine() const;
+  private:
+  bool _internal_has_machine() const;
+  public:
+  void clear_machine();
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine& machine() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* release_machine();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* mutable_machine();
+  void set_allocated_machine(::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* machine);
+  private:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine& _internal_machine() const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* _internal_mutable_machine();
+  public:
+  void unsafe_arena_set_allocated_machine(
+      ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* machine);
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* unsafe_arena_release_machine();
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process process = 3;
+  bool has_process() const;
+  private:
+  bool _internal_has_process() const;
+  public:
+  void clear_process();
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process& process() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* release_process();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* mutable_process();
+  void set_allocated_process(::safe_browsing::ClientIncidentReport_EnvironmentData_Process* process);
+  private:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process& _internal_process() const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* _internal_mutable_process();
+  public:
+  void unsafe_arena_set_allocated_process(
+      ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* process);
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* unsafe_arena_release_process();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* os_;
+    ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* machine_;
+    ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* process_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_ExtensionData_ExtensionInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo) */ {
+ public:
+  inline ClientIncidentReport_ExtensionData_ExtensionInfo() : ClientIncidentReport_ExtensionData_ExtensionInfo(nullptr) {}
+  ~ClientIncidentReport_ExtensionData_ExtensionInfo() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_ExtensionData_ExtensionInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_ExtensionData_ExtensionInfo(const ClientIncidentReport_ExtensionData_ExtensionInfo& from);
+  ClientIncidentReport_ExtensionData_ExtensionInfo(ClientIncidentReport_ExtensionData_ExtensionInfo&& from) noexcept
+    : ClientIncidentReport_ExtensionData_ExtensionInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_ExtensionData_ExtensionInfo& operator=(const ClientIncidentReport_ExtensionData_ExtensionInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_ExtensionData_ExtensionInfo& operator=(ClientIncidentReport_ExtensionData_ExtensionInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_ExtensionData_ExtensionInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_ExtensionData_ExtensionInfo* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_ExtensionData_ExtensionInfo*>(
+               &_ClientIncidentReport_ExtensionData_ExtensionInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    49;
+
+  friend void swap(ClientIncidentReport_ExtensionData_ExtensionInfo& a, ClientIncidentReport_ExtensionData_ExtensionInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_ExtensionData_ExtensionInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_ExtensionData_ExtensionInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_ExtensionData_ExtensionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_ExtensionData_ExtensionInfo>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_ExtensionData_ExtensionInfo& from);
+  void MergeFrom(const ClientIncidentReport_ExtensionData_ExtensionInfo& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_ExtensionData_ExtensionInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo";
+  }
+  protected:
+  explicit ClientIncidentReport_ExtensionData_ExtensionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ExtensionState;
+  static constexpr ExtensionState STATE_UNKNOWN =
+    ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_UNKNOWN;
+  static constexpr ExtensionState STATE_ENABLED =
+    ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_ENABLED;
+  static constexpr ExtensionState STATE_DISABLED =
+    ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_DISABLED;
+  static constexpr ExtensionState STATE_BLACKLISTED =
+    ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_BLACKLISTED;
+  static constexpr ExtensionState STATE_BLOCKED =
+    ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_BLOCKED;
+  static constexpr ExtensionState STATE_TERMINATED =
+    ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_TERMINATED;
+  static inline bool ExtensionState_IsValid(int value) {
+    return ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_IsValid(value);
+  }
+  static constexpr ExtensionState ExtensionState_MIN =
+    ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_MIN;
+  static constexpr ExtensionState ExtensionState_MAX =
+    ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_MAX;
+  static constexpr int ExtensionState_ARRAYSIZE =
+    ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& ExtensionState_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ExtensionState>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ExtensionState_Name.");
+    return ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_Name(enum_t_value);
+  }
+  static inline bool ExtensionState_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ExtensionState* value) {
+    return ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kVersionFieldNumber = 2,
+    kNameFieldNumber = 3,
+    kDescriptionFieldNumber = 4,
+    kUpdateUrlFieldNumber = 7,
+    kManifestFieldNumber = 19,
+    kStateFieldNumber = 5,
+    kTypeFieldNumber = 6,
+    kHasSignatureValidationFieldNumber = 8,
+    kSignatureIsValidFieldNumber = 9,
+    kInstalledByCustodianFieldNumber = 10,
+    kInstalledByDefaultFieldNumber = 11,
+    kInstalledByOemFieldNumber = 12,
+    kFromBookmarkFieldNumber = 13,
+    kFromWebstoreFieldNumber = 14,
+    kConvertedFromUserScriptFieldNumber = 15,
+    kInstallTimeMsecFieldNumber = 17,
+    kMayBeUntrustedFieldNumber = 16,
+    kManifestLocationTypeFieldNumber = 18,
+  };
+  // optional string id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_NODISCARD std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional string version = 2;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  const std::string& version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_version();
+  PROTOBUF_NODISCARD std::string* release_version();
+  void set_allocated_version(std::string* version);
+  private:
+  const std::string& _internal_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
+  std::string* _internal_mutable_version();
+  public:
+
+  // optional string name = 3;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string description = 4;
+  bool has_description() const;
+  private:
+  bool _internal_has_description() const;
+  public:
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_NODISCARD std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // optional string update_url = 7;
+  bool has_update_url() const;
+  private:
+  bool _internal_has_update_url() const;
+  public:
+  void clear_update_url();
+  const std::string& update_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_update_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_update_url();
+  PROTOBUF_NODISCARD std::string* release_update_url();
+  void set_allocated_update_url(std::string* update_url);
+  private:
+  const std::string& _internal_update_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_update_url(const std::string& value);
+  std::string* _internal_mutable_update_url();
+  public:
+
+  // optional string manifest = 19;
+  bool has_manifest() const;
+  private:
+  bool _internal_has_manifest() const;
+  public:
+  void clear_manifest();
+  const std::string& manifest() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_manifest(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_manifest();
+  PROTOBUF_NODISCARD std::string* release_manifest();
+  void set_allocated_manifest(std::string* manifest);
+  private:
+  const std::string& _internal_manifest() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manifest(const std::string& value);
+  std::string* _internal_mutable_manifest();
+  public:
+
+  // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.ExtensionState state = 5 [default = STATE_UNKNOWN];
+  bool has_state() const;
+  private:
+  bool _internal_has_state() const;
+  public:
+  void clear_state();
+  ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState state() const;
+  void set_state(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState value);
+  private:
+  ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState _internal_state() const;
+  void _internal_set_state(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState value);
+  public:
+
+  // optional int32 type = 6;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  int32_t type() const;
+  void set_type(int32_t value);
+  private:
+  int32_t _internal_type() const;
+  void _internal_set_type(int32_t value);
+  public:
+
+  // optional bool has_signature_validation = 8;
+  bool has_has_signature_validation() const;
+  private:
+  bool _internal_has_has_signature_validation() const;
+  public:
+  void clear_has_signature_validation();
+  bool has_signature_validation() const;
+  void set_has_signature_validation(bool value);
+  private:
+  bool _internal_has_signature_validation() const;
+  void _internal_set_has_signature_validation(bool value);
+  public:
+
+  // optional bool signature_is_valid = 9;
+  bool has_signature_is_valid() const;
+  private:
+  bool _internal_has_signature_is_valid() const;
+  public:
+  void clear_signature_is_valid();
+  bool signature_is_valid() const;
+  void set_signature_is_valid(bool value);
+  private:
+  bool _internal_signature_is_valid() const;
+  void _internal_set_signature_is_valid(bool value);
+  public:
+
+  // optional bool installed_by_custodian = 10;
+  bool has_installed_by_custodian() const;
+  private:
+  bool _internal_has_installed_by_custodian() const;
+  public:
+  void clear_installed_by_custodian();
+  bool installed_by_custodian() const;
+  void set_installed_by_custodian(bool value);
+  private:
+  bool _internal_installed_by_custodian() const;
+  void _internal_set_installed_by_custodian(bool value);
+  public:
+
+  // optional bool installed_by_default = 11;
+  bool has_installed_by_default() const;
+  private:
+  bool _internal_has_installed_by_default() const;
+  public:
+  void clear_installed_by_default();
+  bool installed_by_default() const;
+  void set_installed_by_default(bool value);
+  private:
+  bool _internal_installed_by_default() const;
+  void _internal_set_installed_by_default(bool value);
+  public:
+
+  // optional bool installed_by_oem = 12;
+  bool has_installed_by_oem() const;
+  private:
+  bool _internal_has_installed_by_oem() const;
+  public:
+  void clear_installed_by_oem();
+  bool installed_by_oem() const;
+  void set_installed_by_oem(bool value);
+  private:
+  bool _internal_installed_by_oem() const;
+  void _internal_set_installed_by_oem(bool value);
+  public:
+
+  // optional bool from_bookmark = 13;
+  bool has_from_bookmark() const;
+  private:
+  bool _internal_has_from_bookmark() const;
+  public:
+  void clear_from_bookmark();
+  bool from_bookmark() const;
+  void set_from_bookmark(bool value);
+  private:
+  bool _internal_from_bookmark() const;
+  void _internal_set_from_bookmark(bool value);
+  public:
+
+  // optional bool from_webstore = 14;
+  bool has_from_webstore() const;
+  private:
+  bool _internal_has_from_webstore() const;
+  public:
+  void clear_from_webstore();
+  bool from_webstore() const;
+  void set_from_webstore(bool value);
+  private:
+  bool _internal_from_webstore() const;
+  void _internal_set_from_webstore(bool value);
+  public:
+
+  // optional bool converted_from_user_script = 15;
+  bool has_converted_from_user_script() const;
+  private:
+  bool _internal_has_converted_from_user_script() const;
+  public:
+  void clear_converted_from_user_script();
+  bool converted_from_user_script() const;
+  void set_converted_from_user_script(bool value);
+  private:
+  bool _internal_converted_from_user_script() const;
+  void _internal_set_converted_from_user_script(bool value);
+  public:
+
+  // optional int64 install_time_msec = 17;
+  bool has_install_time_msec() const;
+  private:
+  bool _internal_has_install_time_msec() const;
+  public:
+  void clear_install_time_msec();
+  int64_t install_time_msec() const;
+  void set_install_time_msec(int64_t value);
+  private:
+  int64_t _internal_install_time_msec() const;
+  void _internal_set_install_time_msec(int64_t value);
+  public:
+
+  // optional bool may_be_untrusted = 16;
+  bool has_may_be_untrusted() const;
+  private:
+  bool _internal_has_may_be_untrusted() const;
+  public:
+  void clear_may_be_untrusted();
+  bool may_be_untrusted() const;
+  void set_may_be_untrusted(bool value);
+  private:
+  bool _internal_may_be_untrusted() const;
+  void _internal_set_may_be_untrusted(bool value);
+  public:
+
+  // optional int32 manifest_location_type = 18;
+  bool has_manifest_location_type() const;
+  private:
+  bool _internal_has_manifest_location_type() const;
+  public:
+  void clear_manifest_location_type();
+  int32_t manifest_location_type() const;
+  void set_manifest_location_type(int32_t value);
+  private:
+  int32_t _internal_manifest_location_type() const;
+  void _internal_set_manifest_location_type(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr update_url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manifest_;
+    int state_;
+    int32_t type_;
+    bool has_signature_validation_;
+    bool signature_is_valid_;
+    bool installed_by_custodian_;
+    bool installed_by_default_;
+    bool installed_by_oem_;
+    bool from_bookmark_;
+    bool from_webstore_;
+    bool converted_from_user_script_;
+    int64_t install_time_msec_;
+    bool may_be_untrusted_;
+    int32_t manifest_location_type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_ExtensionData final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.ExtensionData) */ {
+ public:
+  inline ClientIncidentReport_ExtensionData() : ClientIncidentReport_ExtensionData(nullptr) {}
+  ~ClientIncidentReport_ExtensionData() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_ExtensionData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_ExtensionData(const ClientIncidentReport_ExtensionData& from);
+  ClientIncidentReport_ExtensionData(ClientIncidentReport_ExtensionData&& from) noexcept
+    : ClientIncidentReport_ExtensionData() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_ExtensionData& operator=(const ClientIncidentReport_ExtensionData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_ExtensionData& operator=(ClientIncidentReport_ExtensionData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_ExtensionData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_ExtensionData* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_ExtensionData*>(
+               &_ClientIncidentReport_ExtensionData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    50;
+
+  friend void swap(ClientIncidentReport_ExtensionData& a, ClientIncidentReport_ExtensionData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_ExtensionData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_ExtensionData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_ExtensionData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_ExtensionData>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_ExtensionData& from);
+  void MergeFrom(const ClientIncidentReport_ExtensionData& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_ExtensionData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.ExtensionData";
+  }
+  protected:
+  explicit ClientIncidentReport_ExtensionData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_ExtensionData_ExtensionInfo ExtensionInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLastInstalledExtensionFieldNumber = 1,
+  };
+  // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo last_installed_extension = 1;
+  bool has_last_installed_extension() const;
+  private:
+  bool _internal_has_last_installed_extension() const;
+  public:
+  void clear_last_installed_extension();
+  const ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo& last_installed_extension() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* release_last_installed_extension();
+  ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* mutable_last_installed_extension();
+  void set_allocated_last_installed_extension(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* last_installed_extension);
+  private:
+  const ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo& _internal_last_installed_extension() const;
+  ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* _internal_mutable_last_installed_extension();
+  public:
+  void unsafe_arena_set_allocated_last_installed_extension(
+      ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* last_installed_extension);
+  ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* unsafe_arena_release_last_installed_extension();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.ExtensionData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* last_installed_extension_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_NonBinaryDownloadDetails final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails) */ {
+ public:
+  inline ClientIncidentReport_NonBinaryDownloadDetails() : ClientIncidentReport_NonBinaryDownloadDetails(nullptr) {}
+  ~ClientIncidentReport_NonBinaryDownloadDetails() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport_NonBinaryDownloadDetails(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport_NonBinaryDownloadDetails(const ClientIncidentReport_NonBinaryDownloadDetails& from);
+  ClientIncidentReport_NonBinaryDownloadDetails(ClientIncidentReport_NonBinaryDownloadDetails&& from) noexcept
+    : ClientIncidentReport_NonBinaryDownloadDetails() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport_NonBinaryDownloadDetails& operator=(const ClientIncidentReport_NonBinaryDownloadDetails& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport_NonBinaryDownloadDetails& operator=(ClientIncidentReport_NonBinaryDownloadDetails&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport_NonBinaryDownloadDetails& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport_NonBinaryDownloadDetails* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport_NonBinaryDownloadDetails*>(
+               &_ClientIncidentReport_NonBinaryDownloadDetails_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    51;
+
+  friend void swap(ClientIncidentReport_NonBinaryDownloadDetails& a, ClientIncidentReport_NonBinaryDownloadDetails& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport_NonBinaryDownloadDetails* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport_NonBinaryDownloadDetails* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_NonBinaryDownloadDetails* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport_NonBinaryDownloadDetails>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport_NonBinaryDownloadDetails& from);
+  void MergeFrom(const ClientIncidentReport_NonBinaryDownloadDetails& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport_NonBinaryDownloadDetails* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails";
+  }
+  protected:
+  explicit ClientIncidentReport_NonBinaryDownloadDetails(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFileTypeFieldNumber = 1,
+    kUrlSpecSha256FieldNumber = 2,
+    kHostFieldNumber = 3,
+    kLengthFieldNumber = 4,
+  };
+  // optional string file_type = 1;
+  bool has_file_type() const;
+  private:
+  bool _internal_has_file_type() const;
+  public:
+  void clear_file_type();
+  const std::string& file_type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_file_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_file_type();
+  PROTOBUF_NODISCARD std::string* release_file_type();
+  void set_allocated_file_type(std::string* file_type);
+  private:
+  const std::string& _internal_file_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_type(const std::string& value);
+  std::string* _internal_mutable_file_type();
+  public:
+
+  // optional bytes url_spec_sha256 = 2;
+  bool has_url_spec_sha256() const;
+  private:
+  bool _internal_has_url_spec_sha256() const;
+  public:
+  void clear_url_spec_sha256();
+  const std::string& url_spec_sha256() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url_spec_sha256(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url_spec_sha256();
+  PROTOBUF_NODISCARD std::string* release_url_spec_sha256();
+  void set_allocated_url_spec_sha256(std::string* url_spec_sha256);
+  private:
+  const std::string& _internal_url_spec_sha256() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url_spec_sha256(const std::string& value);
+  std::string* _internal_mutable_url_spec_sha256();
+  public:
+
+  // optional string host = 3;
+  bool has_host() const;
+  private:
+  bool _internal_has_host() const;
+  public:
+  void clear_host();
+  const std::string& host() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_host(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_host();
+  PROTOBUF_NODISCARD std::string* release_host();
+  void set_allocated_host(std::string* host);
+  private:
+  const std::string& _internal_host() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_host(const std::string& value);
+  std::string* _internal_mutable_host();
+  public:
+
+  // optional int64 length = 4;
+  bool has_length() const;
+  private:
+  bool _internal_has_length() const;
+  public:
+  void clear_length();
+  int64_t length() const;
+  void set_length(int64_t value);
+  private:
+  int64_t _internal_length() const;
+  void _internal_set_length(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_type_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_spec_sha256_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr host_;
+    int64_t length_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport) */ {
+ public:
+  inline ClientIncidentReport() : ClientIncidentReport(nullptr) {}
+  ~ClientIncidentReport() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentReport(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentReport(const ClientIncidentReport& from);
+  ClientIncidentReport(ClientIncidentReport&& from) noexcept
+    : ClientIncidentReport() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentReport& operator=(const ClientIncidentReport& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentReport& operator=(ClientIncidentReport&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentReport& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentReport* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentReport*>(
+               &_ClientIncidentReport_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    52;
+
+  friend void swap(ClientIncidentReport& a, ClientIncidentReport& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentReport* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentReport* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentReport>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentReport& from);
+  void MergeFrom(const ClientIncidentReport& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentReport* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentReport";
+  }
+  protected:
+  explicit ClientIncidentReport(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_IncidentData IncidentData;
+  typedef ClientIncidentReport_DownloadDetails DownloadDetails;
+  typedef ClientIncidentReport_EnvironmentData EnvironmentData;
+  typedef ClientIncidentReport_ExtensionData ExtensionData;
+  typedef ClientIncidentReport_NonBinaryDownloadDetails NonBinaryDownloadDetails;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIncidentFieldNumber = 1,
+    kDownloadFieldNumber = 2,
+    kEnvironmentFieldNumber = 3,
+    kPopulationFieldNumber = 7,
+    kExtensionDataFieldNumber = 8,
+    kNonBinaryDownloadFieldNumber = 9,
+  };
+  // repeated .safe_browsing.ClientIncidentReport.IncidentData incident = 1;
+  int incident_size() const;
+  private:
+  int _internal_incident_size() const;
+  public:
+  void clear_incident();
+  ::safe_browsing::ClientIncidentReport_IncidentData* mutable_incident(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData >*
+      mutable_incident();
+  private:
+  const ::safe_browsing::ClientIncidentReport_IncidentData& _internal_incident(int index) const;
+  ::safe_browsing::ClientIncidentReport_IncidentData* _internal_add_incident();
+  public:
+  const ::safe_browsing::ClientIncidentReport_IncidentData& incident(int index) const;
+  ::safe_browsing::ClientIncidentReport_IncidentData* add_incident();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData >&
+      incident() const;
+
+  // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+  bool has_download() const;
+  private:
+  bool _internal_has_download() const;
+  public:
+  void clear_download();
+  const ::safe_browsing::ClientIncidentReport_DownloadDetails& download() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientIncidentReport_DownloadDetails* release_download();
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* mutable_download();
+  void set_allocated_download(::safe_browsing::ClientIncidentReport_DownloadDetails* download);
+  private:
+  const ::safe_browsing::ClientIncidentReport_DownloadDetails& _internal_download() const;
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* _internal_mutable_download();
+  public:
+  void unsafe_arena_set_allocated_download(
+      ::safe_browsing::ClientIncidentReport_DownloadDetails* download);
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* unsafe_arena_release_download();
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData environment = 3;
+  bool has_environment() const;
+  private:
+  bool _internal_has_environment() const;
+  public:
+  void clear_environment();
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData& environment() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientIncidentReport_EnvironmentData* release_environment();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData* mutable_environment();
+  void set_allocated_environment(::safe_browsing::ClientIncidentReport_EnvironmentData* environment);
+  private:
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData& _internal_environment() const;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData* _internal_mutable_environment();
+  public:
+  void unsafe_arena_set_allocated_environment(
+      ::safe_browsing::ClientIncidentReport_EnvironmentData* environment);
+  ::safe_browsing::ClientIncidentReport_EnvironmentData* unsafe_arena_release_environment();
+
+  // optional .safe_browsing.ChromeUserPopulation population = 7;
+  bool has_population() const;
+  private:
+  bool _internal_has_population() const;
+  public:
+  void clear_population();
+  const ::safe_browsing::ChromeUserPopulation& population() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ChromeUserPopulation* release_population();
+  ::safe_browsing::ChromeUserPopulation* mutable_population();
+  void set_allocated_population(::safe_browsing::ChromeUserPopulation* population);
+  private:
+  const ::safe_browsing::ChromeUserPopulation& _internal_population() const;
+  ::safe_browsing::ChromeUserPopulation* _internal_mutable_population();
+  public:
+  void unsafe_arena_set_allocated_population(
+      ::safe_browsing::ChromeUserPopulation* population);
+  ::safe_browsing::ChromeUserPopulation* unsafe_arena_release_population();
+
+  // optional .safe_browsing.ClientIncidentReport.ExtensionData extension_data = 8;
+  bool has_extension_data() const;
+  private:
+  bool _internal_has_extension_data() const;
+  public:
+  void clear_extension_data();
+  const ::safe_browsing::ClientIncidentReport_ExtensionData& extension_data() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientIncidentReport_ExtensionData* release_extension_data();
+  ::safe_browsing::ClientIncidentReport_ExtensionData* mutable_extension_data();
+  void set_allocated_extension_data(::safe_browsing::ClientIncidentReport_ExtensionData* extension_data);
+  private:
+  const ::safe_browsing::ClientIncidentReport_ExtensionData& _internal_extension_data() const;
+  ::safe_browsing::ClientIncidentReport_ExtensionData* _internal_mutable_extension_data();
+  public:
+  void unsafe_arena_set_allocated_extension_data(
+      ::safe_browsing::ClientIncidentReport_ExtensionData* extension_data);
+  ::safe_browsing::ClientIncidentReport_ExtensionData* unsafe_arena_release_extension_data();
+
+  // optional .safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails non_binary_download = 9;
+  bool has_non_binary_download() const;
+  private:
+  bool _internal_has_non_binary_download() const;
+  public:
+  void clear_non_binary_download();
+  const ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails& non_binary_download() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* release_non_binary_download();
+  ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* mutable_non_binary_download();
+  void set_allocated_non_binary_download(::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* non_binary_download);
+  private:
+  const ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails& _internal_non_binary_download() const;
+  ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* _internal_mutable_non_binary_download();
+  public:
+  void unsafe_arena_set_allocated_non_binary_download(
+      ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* non_binary_download);
+  ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* unsafe_arena_release_non_binary_download();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData > incident_;
+    ::safe_browsing::ClientIncidentReport_DownloadDetails* download_;
+    ::safe_browsing::ClientIncidentReport_EnvironmentData* environment_;
+    ::safe_browsing::ChromeUserPopulation* population_;
+    ::safe_browsing::ClientIncidentReport_ExtensionData* extension_data_;
+    ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* non_binary_download_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentResponse_EnvironmentRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentResponse.EnvironmentRequest) */ {
+ public:
+  inline ClientIncidentResponse_EnvironmentRequest() : ClientIncidentResponse_EnvironmentRequest(nullptr) {}
+  ~ClientIncidentResponse_EnvironmentRequest() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentResponse_EnvironmentRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentResponse_EnvironmentRequest(const ClientIncidentResponse_EnvironmentRequest& from);
+  ClientIncidentResponse_EnvironmentRequest(ClientIncidentResponse_EnvironmentRequest&& from) noexcept
+    : ClientIncidentResponse_EnvironmentRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentResponse_EnvironmentRequest& operator=(const ClientIncidentResponse_EnvironmentRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentResponse_EnvironmentRequest& operator=(ClientIncidentResponse_EnvironmentRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentResponse_EnvironmentRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentResponse_EnvironmentRequest* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentResponse_EnvironmentRequest*>(
+               &_ClientIncidentResponse_EnvironmentRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    53;
+
+  friend void swap(ClientIncidentResponse_EnvironmentRequest& a, ClientIncidentResponse_EnvironmentRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentResponse_EnvironmentRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentResponse_EnvironmentRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentResponse_EnvironmentRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentResponse_EnvironmentRequest>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentResponse_EnvironmentRequest& from);
+  void MergeFrom(const ClientIncidentResponse_EnvironmentRequest& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentResponse_EnvironmentRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentResponse.EnvironmentRequest";
+  }
+  protected:
+  explicit ClientIncidentResponse_EnvironmentRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDllIndexFieldNumber = 1,
+  };
+  // optional int32 dll_index = 1;
+  bool has_dll_index() const;
+  private:
+  bool _internal_has_dll_index() const;
+  public:
+  void clear_dll_index();
+  int32_t dll_index() const;
+  void set_dll_index(int32_t value);
+  private:
+  int32_t _internal_dll_index() const;
+  void _internal_set_dll_index(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int32_t dll_index_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentResponse) */ {
+ public:
+  inline ClientIncidentResponse() : ClientIncidentResponse(nullptr) {}
+  ~ClientIncidentResponse() override;
+  explicit PROTOBUF_CONSTEXPR ClientIncidentResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIncidentResponse(const ClientIncidentResponse& from);
+  ClientIncidentResponse(ClientIncidentResponse&& from) noexcept
+    : ClientIncidentResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIncidentResponse& operator=(const ClientIncidentResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIncidentResponse& operator=(ClientIncidentResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientIncidentResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIncidentResponse* internal_default_instance() {
+    return reinterpret_cast<const ClientIncidentResponse*>(
+               &_ClientIncidentResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    54;
+
+  friend void swap(ClientIncidentResponse& a, ClientIncidentResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIncidentResponse* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIncidentResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientIncidentResponse>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientIncidentResponse& from);
+  void MergeFrom(const ClientIncidentResponse& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientIncidentResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientIncidentResponse";
+  }
+  protected:
+  explicit ClientIncidentResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentResponse_EnvironmentRequest EnvironmentRequest;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEnvironmentRequestsFieldNumber = 3,
+    kTokenFieldNumber = 1,
+    kDownloadRequestedFieldNumber = 2,
+  };
+  // repeated .safe_browsing.ClientIncidentResponse.EnvironmentRequest environment_requests = 3;
+  int environment_requests_size() const;
+  private:
+  int _internal_environment_requests_size() const;
+  public:
+  void clear_environment_requests();
+  ::safe_browsing::ClientIncidentResponse_EnvironmentRequest* mutable_environment_requests(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest >*
+      mutable_environment_requests();
+  private:
+  const ::safe_browsing::ClientIncidentResponse_EnvironmentRequest& _internal_environment_requests(int index) const;
+  ::safe_browsing::ClientIncidentResponse_EnvironmentRequest* _internal_add_environment_requests();
+  public:
+  const ::safe_browsing::ClientIncidentResponse_EnvironmentRequest& environment_requests(int index) const;
+  ::safe_browsing::ClientIncidentResponse_EnvironmentRequest* add_environment_requests();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest >&
+      environment_requests() const;
+
+  // optional bytes token = 1;
+  bool has_token() const;
+  private:
+  bool _internal_has_token() const;
+  public:
+  void clear_token();
+  const std::string& token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_token();
+  PROTOBUF_NODISCARD std::string* release_token();
+  void set_allocated_token(std::string* token);
+  private:
+  const std::string& _internal_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
+  std::string* _internal_mutable_token();
+  public:
+
+  // optional bool download_requested = 2;
+  bool has_download_requested() const;
+  private:
+  bool _internal_has_download_requested() const;
+  public:
+  void clear_download_requested();
+  bool download_requested() const;
+  void set_download_requested(bool value);
+  private:
+  bool _internal_download_requested() const;
+  void _internal_set_download_requested(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest > environment_requests_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
+    bool download_requested_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DownloadMetadata final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.DownloadMetadata) */ {
+ public:
+  inline DownloadMetadata() : DownloadMetadata(nullptr) {}
+  ~DownloadMetadata() override;
+  explicit PROTOBUF_CONSTEXPR DownloadMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DownloadMetadata(const DownloadMetadata& from);
+  DownloadMetadata(DownloadMetadata&& from) noexcept
+    : DownloadMetadata() {
+    *this = ::std::move(from);
+  }
+
+  inline DownloadMetadata& operator=(const DownloadMetadata& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DownloadMetadata& operator=(DownloadMetadata&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const DownloadMetadata& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DownloadMetadata* internal_default_instance() {
+    return reinterpret_cast<const DownloadMetadata*>(
+               &_DownloadMetadata_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    55;
+
+  friend void swap(DownloadMetadata& a, DownloadMetadata& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DownloadMetadata* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DownloadMetadata* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DownloadMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DownloadMetadata>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const DownloadMetadata& from);
+  void MergeFrom(const DownloadMetadata& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(DownloadMetadata* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.DownloadMetadata";
+  }
+  protected:
+  explicit DownloadMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDownloadFieldNumber = 2,
+    kDownloadIdFieldNumber = 1,
+  };
+  // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+  bool has_download() const;
+  private:
+  bool _internal_has_download() const;
+  public:
+  void clear_download();
+  const ::safe_browsing::ClientIncidentReport_DownloadDetails& download() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientIncidentReport_DownloadDetails* release_download();
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* mutable_download();
+  void set_allocated_download(::safe_browsing::ClientIncidentReport_DownloadDetails* download);
+  private:
+  const ::safe_browsing::ClientIncidentReport_DownloadDetails& _internal_download() const;
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* _internal_mutable_download();
+  public:
+  void unsafe_arena_set_allocated_download(
+      ::safe_browsing::ClientIncidentReport_DownloadDetails* download);
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* unsafe_arena_release_download();
+
+  // optional uint32 download_id = 1;
+  bool has_download_id() const;
+  private:
+  bool _internal_has_download_id() const;
+  public:
+  void clear_download_id();
+  uint32_t download_id() const;
+  void set_download_id(uint32_t value);
+  private:
+  uint32_t _internal_download_id() const;
+  void _internal_set_download_id(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.DownloadMetadata)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::safe_browsing::ClientIncidentReport_DownloadDetails* download_;
+    uint32_t download_id_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest_HTTPHeader final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader) */ {
+ public:
+  inline ClientSafeBrowsingReportRequest_HTTPHeader() : ClientSafeBrowsingReportRequest_HTTPHeader(nullptr) {}
+  ~ClientSafeBrowsingReportRequest_HTTPHeader() override;
+  explicit PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientSafeBrowsingReportRequest_HTTPHeader(const ClientSafeBrowsingReportRequest_HTTPHeader& from);
+  ClientSafeBrowsingReportRequest_HTTPHeader(ClientSafeBrowsingReportRequest_HTTPHeader&& from) noexcept
+    : ClientSafeBrowsingReportRequest_HTTPHeader() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientSafeBrowsingReportRequest_HTTPHeader& operator=(const ClientSafeBrowsingReportRequest_HTTPHeader& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientSafeBrowsingReportRequest_HTTPHeader& operator=(ClientSafeBrowsingReportRequest_HTTPHeader&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientSafeBrowsingReportRequest_HTTPHeader& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientSafeBrowsingReportRequest_HTTPHeader* internal_default_instance() {
+    return reinterpret_cast<const ClientSafeBrowsingReportRequest_HTTPHeader*>(
+               &_ClientSafeBrowsingReportRequest_HTTPHeader_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    56;
+
+  friend void swap(ClientSafeBrowsingReportRequest_HTTPHeader& a, ClientSafeBrowsingReportRequest_HTTPHeader& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientSafeBrowsingReportRequest_HTTPHeader* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientSafeBrowsingReportRequest_HTTPHeader* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest_HTTPHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientSafeBrowsingReportRequest_HTTPHeader>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientSafeBrowsingReportRequest_HTTPHeader& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest_HTTPHeader& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientSafeBrowsingReportRequest_HTTPHeader* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader";
+  }
+  protected:
+  explicit ClientSafeBrowsingReportRequest_HTTPHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  // required bytes name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional bytes value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const std::string& value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_value();
+  PROTOBUF_NODISCARD std::string* release_value();
+  void set_allocated_value(std::string* value);
+  private:
+  const std::string& _internal_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+  std::string* _internal_mutable_value();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine) */ {
+ public:
+  inline ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine() : ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(nullptr) {}
+  ~ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine() override;
+  explicit PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from);
+  ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine&& from) noexcept
+    : ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& operator=(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& operator=(ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* internal_default_instance() {
+    return reinterpret_cast<const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine*>(
+               &_ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    57;
+
+  friend void swap(ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& a, ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine";
+  }
+  protected:
+  explicit ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kVerbFieldNumber = 1,
+    kUriFieldNumber = 2,
+    kVersionFieldNumber = 3,
+  };
+  // optional bytes verb = 1;
+  bool has_verb() const;
+  private:
+  bool _internal_has_verb() const;
+  public:
+  void clear_verb();
+  const std::string& verb() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_verb(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_verb();
+  PROTOBUF_NODISCARD std::string* release_verb();
+  void set_allocated_verb(std::string* verb);
+  private:
+  const std::string& _internal_verb() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_verb(const std::string& value);
+  std::string* _internal_mutable_verb();
+  public:
+
+  // optional bytes uri = 2;
+  bool has_uri() const;
+  private:
+  bool _internal_has_uri() const;
+  public:
+  void clear_uri();
+  const std::string& uri() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_uri(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_uri();
+  PROTOBUF_NODISCARD std::string* release_uri();
+  void set_allocated_uri(std::string* uri);
+  private:
+  const std::string& _internal_uri() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri(const std::string& value);
+  std::string* _internal_mutable_uri();
+  public:
+
+  // optional bytes version = 3;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  const std::string& version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_version();
+  PROTOBUF_NODISCARD std::string* release_version();
+  void set_allocated_version(std::string* version);
+  private:
+  const std::string& _internal_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
+  std::string* _internal_mutable_version();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verb_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest_HTTPRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest) */ {
+ public:
+  inline ClientSafeBrowsingReportRequest_HTTPRequest() : ClientSafeBrowsingReportRequest_HTTPRequest(nullptr) {}
+  ~ClientSafeBrowsingReportRequest_HTTPRequest() override;
+  explicit PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientSafeBrowsingReportRequest_HTTPRequest(const ClientSafeBrowsingReportRequest_HTTPRequest& from);
+  ClientSafeBrowsingReportRequest_HTTPRequest(ClientSafeBrowsingReportRequest_HTTPRequest&& from) noexcept
+    : ClientSafeBrowsingReportRequest_HTTPRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientSafeBrowsingReportRequest_HTTPRequest& operator=(const ClientSafeBrowsingReportRequest_HTTPRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientSafeBrowsingReportRequest_HTTPRequest& operator=(ClientSafeBrowsingReportRequest_HTTPRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientSafeBrowsingReportRequest_HTTPRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientSafeBrowsingReportRequest_HTTPRequest* internal_default_instance() {
+    return reinterpret_cast<const ClientSafeBrowsingReportRequest_HTTPRequest*>(
+               &_ClientSafeBrowsingReportRequest_HTTPRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    58;
+
+  friend void swap(ClientSafeBrowsingReportRequest_HTTPRequest& a, ClientSafeBrowsingReportRequest_HTTPRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientSafeBrowsingReportRequest_HTTPRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientSafeBrowsingReportRequest_HTTPRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest_HTTPRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientSafeBrowsingReportRequest_HTTPRequest>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientSafeBrowsingReportRequest_HTTPRequest& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest_HTTPRequest& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientSafeBrowsingReportRequest_HTTPRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest";
+  }
+  protected:
+  explicit ClientSafeBrowsingReportRequest_HTTPRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine FirstLine;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHeadersFieldNumber = 2,
+    kBodyFieldNumber = 3,
+    kBodydigestFieldNumber = 4,
+    kFirstlineFieldNumber = 1,
+    kBodylengthFieldNumber = 5,
+  };
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+  int headers_size() const;
+  private:
+  int _internal_headers_size() const;
+  public:
+  void clear_headers();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* mutable_headers(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >*
+      mutable_headers();
+  private:
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& _internal_headers(int index) const;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* _internal_add_headers();
+  public:
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& headers(int index) const;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* add_headers();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >&
+      headers() const;
+
+  // optional bytes body = 3;
+  bool has_body() const;
+  private:
+  bool _internal_has_body() const;
+  public:
+  void clear_body();
+  const std::string& body() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_body(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_body();
+  PROTOBUF_NODISCARD std::string* release_body();
+  void set_allocated_body(std::string* body);
+  private:
+  const std::string& _internal_body() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value);
+  std::string* _internal_mutable_body();
+  public:
+
+  // optional bytes bodydigest = 4;
+  bool has_bodydigest() const;
+  private:
+  bool _internal_has_bodydigest() const;
+  public:
+  void clear_bodydigest();
+  const std::string& bodydigest() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_bodydigest(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_bodydigest();
+  PROTOBUF_NODISCARD std::string* release_bodydigest();
+  void set_allocated_bodydigest(std::string* bodydigest);
+  private:
+  const std::string& _internal_bodydigest() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bodydigest(const std::string& value);
+  std::string* _internal_mutable_bodydigest();
+  public:
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine firstline = 1;
+  bool has_firstline() const;
+  private:
+  bool _internal_has_firstline() const;
+  public:
+  void clear_firstline();
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& firstline() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* release_firstline();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* mutable_firstline();
+  void set_allocated_firstline(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* firstline);
+  private:
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& _internal_firstline() const;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* _internal_mutable_firstline();
+  public:
+  void unsafe_arena_set_allocated_firstline(
+      ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* firstline);
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* unsafe_arena_release_firstline();
+
+  // optional int32 bodylength = 5;
+  bool has_bodylength() const;
+  private:
+  bool _internal_has_bodylength() const;
+  public:
+  void clear_bodylength();
+  int32_t bodylength() const;
+  void set_bodylength(int32_t value);
+  private:
+  int32_t _internal_bodylength() const;
+  void _internal_set_bodylength(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader > headers_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bodydigest_;
+    ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* firstline_;
+    int32_t bodylength_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine) */ {
+ public:
+  inline ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine() : ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(nullptr) {}
+  ~ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine() override;
+  explicit PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from);
+  ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine&& from) noexcept
+    : ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& operator=(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& operator=(ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* internal_default_instance() {
+    return reinterpret_cast<const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine*>(
+               &_ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    59;
+
+  friend void swap(ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& a, ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine";
+  }
+  protected:
+  explicit ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessageFieldNumber = 2,
+    kVersionFieldNumber = 3,
+    kCodeFieldNumber = 1,
+  };
+  // optional bytes message = 2;
+  bool has_message() const;
+  private:
+  bool _internal_has_message() const;
+  public:
+  void clear_message();
+  const std::string& message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_message();
+  PROTOBUF_NODISCARD std::string* release_message();
+  void set_allocated_message(std::string* message);
+  private:
+  const std::string& _internal_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
+  std::string* _internal_mutable_message();
+  public:
+
+  // optional bytes version = 3;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  const std::string& version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_version();
+  PROTOBUF_NODISCARD std::string* release_version();
+  void set_allocated_version(std::string* version);
+  private:
+  const std::string& _internal_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
+  std::string* _internal_mutable_version();
+  public:
+
+  // optional int32 code = 1;
+  bool has_code() const;
+  private:
+  bool _internal_has_code() const;
+  public:
+  void clear_code();
+  int32_t code() const;
+  void set_code(int32_t value);
+  private:
+  int32_t _internal_code() const;
+  void _internal_set_code(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
+    int32_t code_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest_HTTPResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse) */ {
+ public:
+  inline ClientSafeBrowsingReportRequest_HTTPResponse() : ClientSafeBrowsingReportRequest_HTTPResponse(nullptr) {}
+  ~ClientSafeBrowsingReportRequest_HTTPResponse() override;
+  explicit PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_HTTPResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientSafeBrowsingReportRequest_HTTPResponse(const ClientSafeBrowsingReportRequest_HTTPResponse& from);
+  ClientSafeBrowsingReportRequest_HTTPResponse(ClientSafeBrowsingReportRequest_HTTPResponse&& from) noexcept
+    : ClientSafeBrowsingReportRequest_HTTPResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientSafeBrowsingReportRequest_HTTPResponse& operator=(const ClientSafeBrowsingReportRequest_HTTPResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientSafeBrowsingReportRequest_HTTPResponse& operator=(ClientSafeBrowsingReportRequest_HTTPResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientSafeBrowsingReportRequest_HTTPResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientSafeBrowsingReportRequest_HTTPResponse* internal_default_instance() {
+    return reinterpret_cast<const ClientSafeBrowsingReportRequest_HTTPResponse*>(
+               &_ClientSafeBrowsingReportRequest_HTTPResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    60;
+
+  friend void swap(ClientSafeBrowsingReportRequest_HTTPResponse& a, ClientSafeBrowsingReportRequest_HTTPResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientSafeBrowsingReportRequest_HTTPResponse* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientSafeBrowsingReportRequest_HTTPResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest_HTTPResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientSafeBrowsingReportRequest_HTTPResponse>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientSafeBrowsingReportRequest_HTTPResponse& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest_HTTPResponse& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientSafeBrowsingReportRequest_HTTPResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse";
+  }
+  protected:
+  explicit ClientSafeBrowsingReportRequest_HTTPResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine FirstLine;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHeadersFieldNumber = 2,
+    kBodyFieldNumber = 3,
+    kBodydigestFieldNumber = 4,
+    kRemoteIpFieldNumber = 6,
+    kFirstlineFieldNumber = 1,
+    kBodylengthFieldNumber = 5,
+  };
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+  int headers_size() const;
+  private:
+  int _internal_headers_size() const;
+  public:
+  void clear_headers();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* mutable_headers(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >*
+      mutable_headers();
+  private:
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& _internal_headers(int index) const;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* _internal_add_headers();
+  public:
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& headers(int index) const;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* add_headers();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >&
+      headers() const;
+
+  // optional bytes body = 3;
+  bool has_body() const;
+  private:
+  bool _internal_has_body() const;
+  public:
+  void clear_body();
+  const std::string& body() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_body(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_body();
+  PROTOBUF_NODISCARD std::string* release_body();
+  void set_allocated_body(std::string* body);
+  private:
+  const std::string& _internal_body() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value);
+  std::string* _internal_mutable_body();
+  public:
+
+  // optional bytes bodydigest = 4;
+  bool has_bodydigest() const;
+  private:
+  bool _internal_has_bodydigest() const;
+  public:
+  void clear_bodydigest();
+  const std::string& bodydigest() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_bodydigest(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_bodydigest();
+  PROTOBUF_NODISCARD std::string* release_bodydigest();
+  void set_allocated_bodydigest(std::string* bodydigest);
+  private:
+  const std::string& _internal_bodydigest() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bodydigest(const std::string& value);
+  std::string* _internal_mutable_bodydigest();
+  public:
+
+  // optional bytes remote_ip = 6;
+  bool has_remote_ip() const;
+  private:
+  bool _internal_has_remote_ip() const;
+  public:
+  void clear_remote_ip();
+  const std::string& remote_ip() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_remote_ip(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_remote_ip();
+  PROTOBUF_NODISCARD std::string* release_remote_ip();
+  void set_allocated_remote_ip(std::string* remote_ip);
+  private:
+  const std::string& _internal_remote_ip() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_remote_ip(const std::string& value);
+  std::string* _internal_mutable_remote_ip();
+  public:
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine firstline = 1;
+  bool has_firstline() const;
+  private:
+  bool _internal_has_firstline() const;
+  public:
+  void clear_firstline();
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& firstline() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* release_firstline();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* mutable_firstline();
+  void set_allocated_firstline(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* firstline);
+  private:
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& _internal_firstline() const;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* _internal_mutable_firstline();
+  public:
+  void unsafe_arena_set_allocated_firstline(
+      ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* firstline);
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* unsafe_arena_release_firstline();
+
+  // optional int32 bodylength = 5;
+  bool has_bodylength() const;
+  private:
+  bool _internal_has_bodylength() const;
+  public:
+  void clear_bodylength();
+  int32_t bodylength() const;
+  void set_bodylength(int32_t value);
+  private:
+  int32_t _internal_bodylength() const;
+  void _internal_set_bodylength(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader > headers_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bodydigest_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remote_ip_;
+    ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* firstline_;
+    int32_t bodylength_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest_Resource final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.Resource) */ {
+ public:
+  inline ClientSafeBrowsingReportRequest_Resource() : ClientSafeBrowsingReportRequest_Resource(nullptr) {}
+  ~ClientSafeBrowsingReportRequest_Resource() override;
+  explicit PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_Resource(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientSafeBrowsingReportRequest_Resource(const ClientSafeBrowsingReportRequest_Resource& from);
+  ClientSafeBrowsingReportRequest_Resource(ClientSafeBrowsingReportRequest_Resource&& from) noexcept
+    : ClientSafeBrowsingReportRequest_Resource() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientSafeBrowsingReportRequest_Resource& operator=(const ClientSafeBrowsingReportRequest_Resource& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientSafeBrowsingReportRequest_Resource& operator=(ClientSafeBrowsingReportRequest_Resource&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientSafeBrowsingReportRequest_Resource& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientSafeBrowsingReportRequest_Resource* internal_default_instance() {
+    return reinterpret_cast<const ClientSafeBrowsingReportRequest_Resource*>(
+               &_ClientSafeBrowsingReportRequest_Resource_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    61;
+
+  friend void swap(ClientSafeBrowsingReportRequest_Resource& a, ClientSafeBrowsingReportRequest_Resource& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientSafeBrowsingReportRequest_Resource* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientSafeBrowsingReportRequest_Resource* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest_Resource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientSafeBrowsingReportRequest_Resource>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientSafeBrowsingReportRequest_Resource& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest_Resource& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientSafeBrowsingReportRequest_Resource* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientSafeBrowsingReportRequest.Resource";
+  }
+  protected:
+  explicit ClientSafeBrowsingReportRequest_Resource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kChildIdsFieldNumber = 6,
+    kUrlFieldNumber = 2,
+    kTagNameFieldNumber = 7,
+    kRequestFieldNumber = 3,
+    kResponseFieldNumber = 4,
+    kIdFieldNumber = 1,
+    kParentIdFieldNumber = 5,
+  };
+  // repeated int32 child_ids = 6;
+  int child_ids_size() const;
+  private:
+  int _internal_child_ids_size() const;
+  public:
+  void clear_child_ids();
+  private:
+  int32_t _internal_child_ids(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_child_ids() const;
+  void _internal_add_child_ids(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_child_ids();
+  public:
+  int32_t child_ids(int index) const;
+  void set_child_ids(int index, int32_t value);
+  void add_child_ids(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      child_ids() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_child_ids();
+
+  // optional string url = 2;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string tag_name = 7;
+  bool has_tag_name() const;
+  private:
+  bool _internal_has_tag_name() const;
+  public:
+  void clear_tag_name();
+  const std::string& tag_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_tag_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_tag_name();
+  PROTOBUF_NODISCARD std::string* release_tag_name();
+  void set_allocated_tag_name(std::string* tag_name);
+  private:
+  const std::string& _internal_tag_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tag_name(const std::string& value);
+  std::string* _internal_mutable_tag_name();
+  public:
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest request = 3;
+  bool has_request() const;
+  private:
+  bool _internal_has_request() const;
+  public:
+  void clear_request();
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest& request() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* release_request();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* mutable_request();
+  void set_allocated_request(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* request);
+  private:
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest& _internal_request() const;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* _internal_mutable_request();
+  public:
+  void unsafe_arena_set_allocated_request(
+      ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* request);
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* unsafe_arena_release_request();
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse response = 4;
+  bool has_response() const;
+  private:
+  bool _internal_has_response() const;
+  public:
+  void clear_response();
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse& response() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* release_response();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* mutable_response();
+  void set_allocated_response(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* response);
+  private:
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse& _internal_response() const;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* _internal_mutable_response();
+  public:
+  void unsafe_arena_set_allocated_response(
+      ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* response);
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* unsafe_arena_release_response();
+
+  // required int32 id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  int32_t id() const;
+  void set_id(int32_t value);
+  private:
+  int32_t _internal_id() const;
+  void _internal_set_id(int32_t value);
+  public:
+
+  // optional int32 parent_id = 5;
+  bool has_parent_id() const;
+  private:
+  bool _internal_has_parent_id() const;
+  public:
+  void clear_parent_id();
+  int32_t parent_id() const;
+  void set_parent_id(int32_t value);
+  private:
+  int32_t _internal_parent_id() const;
+  void _internal_set_parent_id(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > child_ids_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tag_name_;
+    ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* request_;
+    ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* response_;
+    int32_t id_;
+    int32_t parent_id_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties) */ {
+ public:
+  inline ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties() : ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(nullptr) {}
+  ~ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties() override;
+  explicit PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& from);
+  ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties&& from) noexcept
+    : ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& operator=(const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& operator=(ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* internal_default_instance() {
+    return reinterpret_cast<const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties*>(
+               &_ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    62;
+
+  friend void swap(ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& a, ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties";
+  }
+  protected:
+  explicit ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kClientVersionFieldNumber = 1,
+    kGooglePlayServicesVersionFieldNumber = 2,
+    kIsInstantAppsFieldNumber = 3,
+    kUrlApiTypeFieldNumber = 4,
+  };
+  // optional string client_version = 1;
+  bool has_client_version() const;
+  private:
+  bool _internal_has_client_version() const;
+  public:
+  void clear_client_version();
+  const std::string& client_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_version();
+  PROTOBUF_NODISCARD std::string* release_client_version();
+  void set_allocated_client_version(std::string* client_version);
+  private:
+  const std::string& _internal_client_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_version(const std::string& value);
+  std::string* _internal_mutable_client_version();
+  public:
+
+  // optional int64 google_play_services_version = 2;
+  bool has_google_play_services_version() const;
+  private:
+  bool _internal_has_google_play_services_version() const;
+  public:
+  void clear_google_play_services_version();
+  int64_t google_play_services_version() const;
+  void set_google_play_services_version(int64_t value);
+  private:
+  int64_t _internal_google_play_services_version() const;
+  void _internal_set_google_play_services_version(int64_t value);
+  public:
+
+  // optional bool is_instant_apps = 3;
+  bool has_is_instant_apps() const;
+  private:
+  bool _internal_has_is_instant_apps() const;
+  public:
+  void clear_is_instant_apps();
+  bool is_instant_apps() const;
+  void set_is_instant_apps(bool value);
+  private:
+  bool _internal_is_instant_apps() const;
+  void _internal_set_is_instant_apps(bool value);
+  public:
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingUrlApiType url_api_type = 4;
+  bool has_url_api_type() const;
+  private:
+  bool _internal_has_url_api_type() const;
+  public:
+  void clear_url_api_type();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType url_api_type() const;
+  void set_url_api_type(::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType value);
+  private:
+  ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType _internal_url_api_type() const;
+  void _internal_set_url_api_type(::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_version_;
+    int64_t google_play_services_version_;
+    bool is_instant_apps_;
+    int url_api_type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest) */ {
+ public:
+  inline ClientSafeBrowsingReportRequest() : ClientSafeBrowsingReportRequest(nullptr) {}
+  ~ClientSafeBrowsingReportRequest() override;
+  explicit PROTOBUF_CONSTEXPR ClientSafeBrowsingReportRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientSafeBrowsingReportRequest(const ClientSafeBrowsingReportRequest& from);
+  ClientSafeBrowsingReportRequest(ClientSafeBrowsingReportRequest&& from) noexcept
+    : ClientSafeBrowsingReportRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientSafeBrowsingReportRequest& operator=(const ClientSafeBrowsingReportRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientSafeBrowsingReportRequest& operator=(ClientSafeBrowsingReportRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ClientSafeBrowsingReportRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientSafeBrowsingReportRequest* internal_default_instance() {
+    return reinterpret_cast<const ClientSafeBrowsingReportRequest*>(
+               &_ClientSafeBrowsingReportRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    63;
+
+  friend void swap(ClientSafeBrowsingReportRequest& a, ClientSafeBrowsingReportRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientSafeBrowsingReportRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientSafeBrowsingReportRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ClientSafeBrowsingReportRequest>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ClientSafeBrowsingReportRequest& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ClientSafeBrowsingReportRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ClientSafeBrowsingReportRequest";
+  }
+  protected:
+  explicit ClientSafeBrowsingReportRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientSafeBrowsingReportRequest_HTTPHeader HTTPHeader;
+  typedef ClientSafeBrowsingReportRequest_HTTPRequest HTTPRequest;
+  typedef ClientSafeBrowsingReportRequest_HTTPResponse HTTPResponse;
+  typedef ClientSafeBrowsingReportRequest_Resource Resource;
+  typedef ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties SafeBrowsingClientProperties;
+
+  typedef ClientSafeBrowsingReportRequest_ReportType ReportType;
+  static constexpr ReportType UNKNOWN =
+    ClientSafeBrowsingReportRequest_ReportType_UNKNOWN;
+  static constexpr ReportType URL_PHISHING =
+    ClientSafeBrowsingReportRequest_ReportType_URL_PHISHING;
+  static constexpr ReportType URL_MALWARE =
+    ClientSafeBrowsingReportRequest_ReportType_URL_MALWARE;
+  static constexpr ReportType URL_UNWANTED =
+    ClientSafeBrowsingReportRequest_ReportType_URL_UNWANTED;
+  static constexpr ReportType URL_CLIENT_SIDE_PHISHING =
+    ClientSafeBrowsingReportRequest_ReportType_URL_CLIENT_SIDE_PHISHING;
+  static constexpr ReportType URL_CLIENT_SIDE_MALWARE =
+    ClientSafeBrowsingReportRequest_ReportType_URL_CLIENT_SIDE_MALWARE;
+  static constexpr ReportType DANGEROUS_DOWNLOAD_RECOVERY =
+    ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_RECOVERY;
+  static constexpr ReportType DANGEROUS_DOWNLOAD_WARNING =
+    ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_WARNING;
+  static constexpr ReportType DANGEROUS_DOWNLOAD_BY_API =
+    ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_BY_API;
+  static constexpr ReportType URL_PASSWORD_PROTECTION_PHISHING =
+    ClientSafeBrowsingReportRequest_ReportType_URL_PASSWORD_PROTECTION_PHISHING;
+  static constexpr ReportType DANGEROUS_DOWNLOAD_OPENED =
+    ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_OPENED;
+  static constexpr ReportType AD_SAMPLE =
+    ClientSafeBrowsingReportRequest_ReportType_AD_SAMPLE;
+  static inline bool ReportType_IsValid(int value) {
+    return ClientSafeBrowsingReportRequest_ReportType_IsValid(value);
+  }
+  static constexpr ReportType ReportType_MIN =
+    ClientSafeBrowsingReportRequest_ReportType_ReportType_MIN;
+  static constexpr ReportType ReportType_MAX =
+    ClientSafeBrowsingReportRequest_ReportType_ReportType_MAX;
+  static constexpr int ReportType_ARRAYSIZE =
+    ClientSafeBrowsingReportRequest_ReportType_ReportType_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& ReportType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ReportType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ReportType_Name.");
+    return ClientSafeBrowsingReportRequest_ReportType_Name(enum_t_value);
+  }
+  static inline bool ReportType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ReportType* value) {
+    return ClientSafeBrowsingReportRequest_ReportType_Parse(name, value);
+  }
+
+  typedef ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType SafeBrowsingUrlApiType;
+  static constexpr SafeBrowsingUrlApiType SAFE_BROWSING_URL_API_TYPE_UNSPECIFIED =
+    ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_SAFE_BROWSING_URL_API_TYPE_UNSPECIFIED;
+  static constexpr SafeBrowsingUrlApiType PVER3_NATIVE =
+    ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_PVER3_NATIVE;
+  static constexpr SafeBrowsingUrlApiType PVER4_NATIVE =
+    ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_PVER4_NATIVE;
+  static constexpr SafeBrowsingUrlApiType ANDROID_SAFETYNET =
+    ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_ANDROID_SAFETYNET;
+  static constexpr SafeBrowsingUrlApiType FLYWHEEL =
+    ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_FLYWHEEL;
+  static inline bool SafeBrowsingUrlApiType_IsValid(int value) {
+    return ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_IsValid(value);
+  }
+  static constexpr SafeBrowsingUrlApiType SafeBrowsingUrlApiType_MIN =
+    ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_SafeBrowsingUrlApiType_MIN;
+  static constexpr SafeBrowsingUrlApiType SafeBrowsingUrlApiType_MAX =
+    ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_SafeBrowsingUrlApiType_MAX;
+  static constexpr int SafeBrowsingUrlApiType_ARRAYSIZE =
+    ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_SafeBrowsingUrlApiType_ARRAYSIZE;
+  template<typename T>
+  static inline const std::string& SafeBrowsingUrlApiType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SafeBrowsingUrlApiType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SafeBrowsingUrlApiType_Name.");
+    return ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_Name(enum_t_value);
+  }
+  static inline bool SafeBrowsingUrlApiType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SafeBrowsingUrlApiType* value) {
+    return ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kResourcesFieldNumber = 4,
+    kClientAsnFieldNumber = 6,
+    kDomFieldNumber = 16,
+    kUrlFieldNumber = 1,
+    kPageUrlFieldNumber = 2,
+    kReferrerUrlFieldNumber = 3,
+    kClientCountryFieldNumber = 7,
+    kTokenFieldNumber = 15,
+    kClientPropertiesFieldNumber = 17,
+    kTypeFieldNumber = 10,
+    kCompleteFieldNumber = 5,
+    kDidProceedFieldNumber = 8,
+    kRepeatVisitFieldNumber = 9,
+    kShowDownloadInFolderFieldNumber = 18,
+    kDownloadVerdictFieldNumber = 11,
+  };
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.Resource resources = 4;
+  int resources_size() const;
+  private:
+  int _internal_resources_size() const;
+  public:
+  void clear_resources();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* mutable_resources(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource >*
+      mutable_resources();
+  private:
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_Resource& _internal_resources(int index) const;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* _internal_add_resources();
+  public:
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_Resource& resources(int index) const;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* add_resources();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource >&
+      resources() const;
+
+  // repeated string client_asn = 6;
+  int client_asn_size() const;
+  private:
+  int _internal_client_asn_size() const;
+  public:
+  void clear_client_asn();
+  const std::string& client_asn(int index) const;
+  std::string* mutable_client_asn(int index);
+  void set_client_asn(int index, const std::string& value);
+  void set_client_asn(int index, std::string&& value);
+  void set_client_asn(int index, const char* value);
+  void set_client_asn(int index, const char* value, size_t size);
+  std::string* add_client_asn();
+  void add_client_asn(const std::string& value);
+  void add_client_asn(std::string&& value);
+  void add_client_asn(const char* value);
+  void add_client_asn(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& client_asn() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_client_asn();
+  private:
+  const std::string& _internal_client_asn(int index) const;
+  std::string* _internal_add_client_asn();
+  public:
+
+  // repeated .safe_browsing.HTMLElement dom = 16;
+  int dom_size() const;
+  private:
+  int _internal_dom_size() const;
+  public:
+  void clear_dom();
+  ::safe_browsing::HTMLElement* mutable_dom(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::HTMLElement >*
+      mutable_dom();
+  private:
+  const ::safe_browsing::HTMLElement& _internal_dom(int index) const;
+  ::safe_browsing::HTMLElement* _internal_add_dom();
+  public:
+  const ::safe_browsing::HTMLElement& dom(int index) const;
+  ::safe_browsing::HTMLElement* add_dom();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::HTMLElement >&
+      dom() const;
+
+  // optional string url = 1;
+  bool has_url() const;
+  private:
+  bool _internal_has_url() const;
+  public:
+  void clear_url();
+  const std::string& url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_url();
+  PROTOBUF_NODISCARD std::string* release_url();
+  void set_allocated_url(std::string* url);
+  private:
+  const std::string& _internal_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
+  std::string* _internal_mutable_url();
+  public:
+
+  // optional string page_url = 2;
+  bool has_page_url() const;
+  private:
+  bool _internal_has_page_url() const;
+  public:
+  void clear_page_url();
+  const std::string& page_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_page_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_page_url();
+  PROTOBUF_NODISCARD std::string* release_page_url();
+  void set_allocated_page_url(std::string* page_url);
+  private:
+  const std::string& _internal_page_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_page_url(const std::string& value);
+  std::string* _internal_mutable_page_url();
+  public:
+
+  // optional string referrer_url = 3;
+  bool has_referrer_url() const;
+  private:
+  bool _internal_has_referrer_url() const;
+  public:
+  void clear_referrer_url();
+  const std::string& referrer_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_referrer_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_referrer_url();
+  PROTOBUF_NODISCARD std::string* release_referrer_url();
+  void set_allocated_referrer_url(std::string* referrer_url);
+  private:
+  const std::string& _internal_referrer_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_referrer_url(const std::string& value);
+  std::string* _internal_mutable_referrer_url();
+  public:
+
+  // optional string client_country = 7;
+  bool has_client_country() const;
+  private:
+  bool _internal_has_client_country() const;
+  public:
+  void clear_client_country();
+  const std::string& client_country() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_country(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_country();
+  PROTOBUF_NODISCARD std::string* release_client_country();
+  void set_allocated_client_country(std::string* client_country);
+  private:
+  const std::string& _internal_client_country() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_country(const std::string& value);
+  std::string* _internal_mutable_client_country();
+  public:
+
+  // optional bytes token = 15;
+  bool has_token() const;
+  private:
+  bool _internal_has_token() const;
+  public:
+  void clear_token();
+  const std::string& token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_token();
+  PROTOBUF_NODISCARD std::string* release_token();
+  void set_allocated_token(std::string* token);
+  private:
+  const std::string& _internal_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
+  std::string* _internal_mutable_token();
+  public:
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties client_properties = 17;
+  bool has_client_properties() const;
+  private:
+  bool _internal_has_client_properties() const;
+  public:
+  void clear_client_properties();
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& client_properties() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* release_client_properties();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* mutable_client_properties();
+  void set_allocated_client_properties(::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* client_properties);
+  private:
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& _internal_client_properties() const;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* _internal_mutable_client_properties();
+  public:
+  void unsafe_arena_set_allocated_client_properties(
+      ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* client_properties);
+  ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* unsafe_arena_release_client_properties();
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.ReportType type = 10;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_ReportType type() const;
+  void set_type(::safe_browsing::ClientSafeBrowsingReportRequest_ReportType value);
+  private:
+  ::safe_browsing::ClientSafeBrowsingReportRequest_ReportType _internal_type() const;
+  void _internal_set_type(::safe_browsing::ClientSafeBrowsingReportRequest_ReportType value);
+  public:
+
+  // optional bool complete = 5;
+  bool has_complete() const;
+  private:
+  bool _internal_has_complete() const;
+  public:
+  void clear_complete();
+  bool complete() const;
+  void set_complete(bool value);
+  private:
+  bool _internal_complete() const;
+  void _internal_set_complete(bool value);
+  public:
+
+  // optional bool did_proceed = 8;
+  bool has_did_proceed() const;
+  private:
+  bool _internal_has_did_proceed() const;
+  public:
+  void clear_did_proceed();
+  bool did_proceed() const;
+  void set_did_proceed(bool value);
+  private:
+  bool _internal_did_proceed() const;
+  void _internal_set_did_proceed(bool value);
+  public:
+
+  // optional bool repeat_visit = 9;
+  bool has_repeat_visit() const;
+  private:
+  bool _internal_has_repeat_visit() const;
+  public:
+  void clear_repeat_visit();
+  bool repeat_visit() const;
+  void set_repeat_visit(bool value);
+  private:
+  bool _internal_repeat_visit() const;
+  void _internal_set_repeat_visit(bool value);
+  public:
+
+  // optional bool show_download_in_folder = 18;
+  bool has_show_download_in_folder() const;
+  private:
+  bool _internal_has_show_download_in_folder() const;
+  public:
+  void clear_show_download_in_folder();
+  bool show_download_in_folder() const;
+  void set_show_download_in_folder(bool value);
+  private:
+  bool _internal_show_download_in_folder() const;
+  void _internal_set_show_download_in_folder(bool value);
+  public:
+
+  // optional .safe_browsing.ClientDownloadResponse.Verdict download_verdict = 11;
+  bool has_download_verdict() const;
+  private:
+  bool _internal_has_download_verdict() const;
+  public:
+  void clear_download_verdict();
+  ::safe_browsing::ClientDownloadResponse_Verdict download_verdict() const;
+  void set_download_verdict(::safe_browsing::ClientDownloadResponse_Verdict value);
+  private:
+  ::safe_browsing::ClientDownloadResponse_Verdict _internal_download_verdict() const;
+  void _internal_set_download_verdict(::safe_browsing::ClientDownloadResponse_Verdict value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource > resources_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> client_asn_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::HTMLElement > dom_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr page_url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr referrer_url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_country_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
+    ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* client_properties_;
+    int type_;
+    bool complete_;
+    bool did_proceed_;
+    bool repeat_visit_;
+    bool show_download_in_folder_;
+    int download_verdict_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HTMLElement_Attribute final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.HTMLElement.Attribute) */ {
+ public:
+  inline HTMLElement_Attribute() : HTMLElement_Attribute(nullptr) {}
+  ~HTMLElement_Attribute() override;
+  explicit PROTOBUF_CONSTEXPR HTMLElement_Attribute(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HTMLElement_Attribute(const HTMLElement_Attribute& from);
+  HTMLElement_Attribute(HTMLElement_Attribute&& from) noexcept
+    : HTMLElement_Attribute() {
+    *this = ::std::move(from);
+  }
+
+  inline HTMLElement_Attribute& operator=(const HTMLElement_Attribute& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HTMLElement_Attribute& operator=(HTMLElement_Attribute&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const HTMLElement_Attribute& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HTMLElement_Attribute* internal_default_instance() {
+    return reinterpret_cast<const HTMLElement_Attribute*>(
+               &_HTMLElement_Attribute_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    64;
+
+  friend void swap(HTMLElement_Attribute& a, HTMLElement_Attribute& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HTMLElement_Attribute* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HTMLElement_Attribute* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HTMLElement_Attribute* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HTMLElement_Attribute>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const HTMLElement_Attribute& from);
+  void MergeFrom(const HTMLElement_Attribute& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(HTMLElement_Attribute* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.HTMLElement.Attribute";
+  }
+  protected:
+  explicit HTMLElement_Attribute(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const std::string& value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_value();
+  PROTOBUF_NODISCARD std::string* release_value();
+  void set_allocated_value(std::string* value);
+  private:
+  const std::string& _internal_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+  std::string* _internal_mutable_value();
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.HTMLElement.Attribute)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class HTMLElement final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.HTMLElement) */ {
+ public:
+  inline HTMLElement() : HTMLElement(nullptr) {}
+  ~HTMLElement() override;
+  explicit PROTOBUF_CONSTEXPR HTMLElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HTMLElement(const HTMLElement& from);
+  HTMLElement(HTMLElement&& from) noexcept
+    : HTMLElement() {
+    *this = ::std::move(from);
+  }
+
+  inline HTMLElement& operator=(const HTMLElement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HTMLElement& operator=(HTMLElement&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const HTMLElement& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HTMLElement* internal_default_instance() {
+    return reinterpret_cast<const HTMLElement*>(
+               &_HTMLElement_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    65;
+
+  friend void swap(HTMLElement& a, HTMLElement& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HTMLElement* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HTMLElement* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HTMLElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HTMLElement>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const HTMLElement& from);
+  void MergeFrom(const HTMLElement& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(HTMLElement* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.HTMLElement";
+  }
+  protected:
+  explicit HTMLElement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef HTMLElement_Attribute Attribute;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kChildIdsFieldNumber = 3,
+    kAttributeFieldNumber = 6,
+    kTagFieldNumber = 2,
+    kIdFieldNumber = 1,
+    kResourceIdFieldNumber = 5,
+  };
+  // repeated int32 child_ids = 3;
+  int child_ids_size() const;
+  private:
+  int _internal_child_ids_size() const;
+  public:
+  void clear_child_ids();
+  private:
+  int32_t _internal_child_ids(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_child_ids() const;
+  void _internal_add_child_ids(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_child_ids();
+  public:
+  int32_t child_ids(int index) const;
+  void set_child_ids(int index, int32_t value);
+  void add_child_ids(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      child_ids() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_child_ids();
+
+  // repeated .safe_browsing.HTMLElement.Attribute attribute = 6;
+  int attribute_size() const;
+  private:
+  int _internal_attribute_size() const;
+  public:
+  void clear_attribute();
+  ::safe_browsing::HTMLElement_Attribute* mutable_attribute(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::HTMLElement_Attribute >*
+      mutable_attribute();
+  private:
+  const ::safe_browsing::HTMLElement_Attribute& _internal_attribute(int index) const;
+  ::safe_browsing::HTMLElement_Attribute* _internal_add_attribute();
+  public:
+  const ::safe_browsing::HTMLElement_Attribute& attribute(int index) const;
+  ::safe_browsing::HTMLElement_Attribute* add_attribute();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::HTMLElement_Attribute >&
+      attribute() const;
+
+  // optional string tag = 2;
+  bool has_tag() const;
+  private:
+  bool _internal_has_tag() const;
+  public:
+  void clear_tag();
+  const std::string& tag() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_tag(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_tag();
+  PROTOBUF_NODISCARD std::string* release_tag();
+  void set_allocated_tag(std::string* tag);
+  private:
+  const std::string& _internal_tag() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tag(const std::string& value);
+  std::string* _internal_mutable_tag();
+  public:
+
+  // optional int32 id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  int32_t id() const;
+  void set_id(int32_t value);
+  private:
+  int32_t _internal_id() const;
+  void _internal_set_id(int32_t value);
+  public:
+
+  // optional int32 resource_id = 5;
+  bool has_resource_id() const;
+  private:
+  bool _internal_has_resource_id() const;
+  public:
+  void clear_resource_id();
+  int32_t resource_id() const;
+  void set_resource_id(int32_t value);
+  private:
+  int32_t _internal_resource_id() const;
+  void _internal_set_resource_id(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.HTMLElement)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > child_ids_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::HTMLElement_Attribute > attribute_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tag_;
+    int32_t id_;
+    int32_t resource_id_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ImageData_Dimensions final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ImageData.Dimensions) */ {
+ public:
+  inline ImageData_Dimensions() : ImageData_Dimensions(nullptr) {}
+  ~ImageData_Dimensions() override;
+  explicit PROTOBUF_CONSTEXPR ImageData_Dimensions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ImageData_Dimensions(const ImageData_Dimensions& from);
+  ImageData_Dimensions(ImageData_Dimensions&& from) noexcept
+    : ImageData_Dimensions() {
+    *this = ::std::move(from);
+  }
+
+  inline ImageData_Dimensions& operator=(const ImageData_Dimensions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ImageData_Dimensions& operator=(ImageData_Dimensions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ImageData_Dimensions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ImageData_Dimensions* internal_default_instance() {
+    return reinterpret_cast<const ImageData_Dimensions*>(
+               &_ImageData_Dimensions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    66;
+
+  friend void swap(ImageData_Dimensions& a, ImageData_Dimensions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ImageData_Dimensions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ImageData_Dimensions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ImageData_Dimensions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ImageData_Dimensions>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ImageData_Dimensions& from);
+  void MergeFrom(const ImageData_Dimensions& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ImageData_Dimensions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ImageData.Dimensions";
+  }
+  protected:
+  explicit ImageData_Dimensions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kWidthFieldNumber = 1,
+    kHeightFieldNumber = 2,
+  };
+  // optional int32 width = 1;
+  bool has_width() const;
+  private:
+  bool _internal_has_width() const;
+  public:
+  void clear_width();
+  int32_t width() const;
+  void set_width(int32_t value);
+  private:
+  int32_t _internal_width() const;
+  void _internal_set_width(int32_t value);
+  public:
+
+  // optional int32 height = 2;
+  bool has_height() const;
+  private:
+  bool _internal_has_height() const;
+  public:
+  void clear_height();
+  int32_t height() const;
+  void set_height(int32_t value);
+  private:
+  int32_t _internal_height() const;
+  void _internal_set_height(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ImageData.Dimensions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int32_t width_;
+    int32_t height_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ImageData final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ImageData) */ {
+ public:
+  inline ImageData() : ImageData(nullptr) {}
+  ~ImageData() override;
+  explicit PROTOBUF_CONSTEXPR ImageData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ImageData(const ImageData& from);
+  ImageData(ImageData&& from) noexcept
+    : ImageData() {
+    *this = ::std::move(from);
+  }
+
+  inline ImageData& operator=(const ImageData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ImageData& operator=(ImageData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const ImageData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ImageData* internal_default_instance() {
+    return reinterpret_cast<const ImageData*>(
+               &_ImageData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    67;
+
+  friend void swap(ImageData& a, ImageData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ImageData* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ImageData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ImageData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ImageData>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const ImageData& from);
+  void MergeFrom(const ImageData& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ImageData* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.ImageData";
+  }
+  protected:
+  explicit ImageData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ImageData_Dimensions Dimensions;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDataFieldNumber = 1,
+    kMimeTypeFieldNumber = 2,
+    kDimensionsFieldNumber = 3,
+    kOriginalDimensionsFieldNumber = 4,
+  };
+  // optional bytes data = 1;
+  bool has_data() const;
+  private:
+  bool _internal_has_data() const;
+  public:
+  void clear_data();
+  const std::string& data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_data();
+  PROTOBUF_NODISCARD std::string* release_data();
+  void set_allocated_data(std::string* data);
+  private:
+  const std::string& _internal_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
+  std::string* _internal_mutable_data();
+  public:
+
+  // optional string mime_type = 2;
+  bool has_mime_type() const;
+  private:
+  bool _internal_has_mime_type() const;
+  public:
+  void clear_mime_type();
+  const std::string& mime_type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mime_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mime_type();
+  PROTOBUF_NODISCARD std::string* release_mime_type();
+  void set_allocated_mime_type(std::string* mime_type);
+  private:
+  const std::string& _internal_mime_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mime_type(const std::string& value);
+  std::string* _internal_mutable_mime_type();
+  public:
+
+  // optional .safe_browsing.ImageData.Dimensions dimensions = 3;
+  bool has_dimensions() const;
+  private:
+  bool _internal_has_dimensions() const;
+  public:
+  void clear_dimensions();
+  const ::safe_browsing::ImageData_Dimensions& dimensions() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ImageData_Dimensions* release_dimensions();
+  ::safe_browsing::ImageData_Dimensions* mutable_dimensions();
+  void set_allocated_dimensions(::safe_browsing::ImageData_Dimensions* dimensions);
+  private:
+  const ::safe_browsing::ImageData_Dimensions& _internal_dimensions() const;
+  ::safe_browsing::ImageData_Dimensions* _internal_mutable_dimensions();
+  public:
+  void unsafe_arena_set_allocated_dimensions(
+      ::safe_browsing::ImageData_Dimensions* dimensions);
+  ::safe_browsing::ImageData_Dimensions* unsafe_arena_release_dimensions();
+
+  // optional .safe_browsing.ImageData.Dimensions original_dimensions = 4;
+  bool has_original_dimensions() const;
+  private:
+  bool _internal_has_original_dimensions() const;
+  public:
+  void clear_original_dimensions();
+  const ::safe_browsing::ImageData_Dimensions& original_dimensions() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ImageData_Dimensions* release_original_dimensions();
+  ::safe_browsing::ImageData_Dimensions* mutable_original_dimensions();
+  void set_allocated_original_dimensions(::safe_browsing::ImageData_Dimensions* original_dimensions);
+  private:
+  const ::safe_browsing::ImageData_Dimensions& _internal_original_dimensions() const;
+  ::safe_browsing::ImageData_Dimensions* _internal_mutable_original_dimensions();
+  public:
+  void unsafe_arena_set_allocated_original_dimensions(
+      ::safe_browsing::ImageData_Dimensions* original_dimensions);
+  ::safe_browsing::ImageData_Dimensions* unsafe_arena_release_original_dimensions();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ImageData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mime_type_;
+    ::safe_browsing::ImageData_Dimensions* dimensions_;
+    ::safe_browsing::ImageData_Dimensions* original_dimensions_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// -------------------------------------------------------------------
+
+class NotificationImageReportRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.NotificationImageReportRequest) */ {
+ public:
+  inline NotificationImageReportRequest() : NotificationImageReportRequest(nullptr) {}
+  ~NotificationImageReportRequest() override;
+  explicit PROTOBUF_CONSTEXPR NotificationImageReportRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  NotificationImageReportRequest(const NotificationImageReportRequest& from);
+  NotificationImageReportRequest(NotificationImageReportRequest&& from) noexcept
+    : NotificationImageReportRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline NotificationImageReportRequest& operator=(const NotificationImageReportRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline NotificationImageReportRequest& operator=(NotificationImageReportRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const NotificationImageReportRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const NotificationImageReportRequest* internal_default_instance() {
+    return reinterpret_cast<const NotificationImageReportRequest*>(
+               &_NotificationImageReportRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    68;
+
+  friend void swap(NotificationImageReportRequest& a, NotificationImageReportRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(NotificationImageReportRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(NotificationImageReportRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  NotificationImageReportRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<NotificationImageReportRequest>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const NotificationImageReportRequest& from);
+  void MergeFrom(const NotificationImageReportRequest& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(NotificationImageReportRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "safe_browsing.NotificationImageReportRequest";
+  }
+  protected:
+  explicit NotificationImageReportRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNotificationOriginFieldNumber = 1,
+    kImageFieldNumber = 2,
+  };
+  // optional string notification_origin = 1;
+  bool has_notification_origin() const;
+  private:
+  bool _internal_has_notification_origin() const;
+  public:
+  void clear_notification_origin();
+  const std::string& notification_origin() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_notification_origin(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_notification_origin();
+  PROTOBUF_NODISCARD std::string* release_notification_origin();
+  void set_allocated_notification_origin(std::string* notification_origin);
+  private:
+  const std::string& _internal_notification_origin() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_notification_origin(const std::string& value);
+  std::string* _internal_mutable_notification_origin();
+  public:
+
+  // optional .safe_browsing.ImageData image = 2;
+  bool has_image() const;
+  private:
+  bool _internal_has_image() const;
+  public:
+  void clear_image();
+  const ::safe_browsing::ImageData& image() const;
+  PROTOBUF_NODISCARD ::safe_browsing::ImageData* release_image();
+  ::safe_browsing::ImageData* mutable_image();
+  void set_allocated_image(::safe_browsing::ImageData* image);
+  private:
+  const ::safe_browsing::ImageData& _internal_image() const;
+  ::safe_browsing::ImageData* _internal_mutable_image();
+  public:
+  void unsafe_arena_set_allocated_image(
+      ::safe_browsing::ImageData* image);
+  ::safe_browsing::ImageData* unsafe_arena_release_image();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.NotificationImageReportRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr notification_origin_;
+    ::safe_browsing::ImageData* image_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_csd_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ChromeUserPopulation
+
+// optional .safe_browsing.ChromeUserPopulation.UserPopulation user_population = 1;
+inline bool ChromeUserPopulation::_internal_has_user_population() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ChromeUserPopulation::has_user_population() const {
+  return _internal_has_user_population();
+}
+inline void ChromeUserPopulation::clear_user_population() {
+  _impl_.user_population_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline ::safe_browsing::ChromeUserPopulation_UserPopulation ChromeUserPopulation::_internal_user_population() const {
+  return static_cast< ::safe_browsing::ChromeUserPopulation_UserPopulation >(_impl_.user_population_);
+}
+inline ::safe_browsing::ChromeUserPopulation_UserPopulation ChromeUserPopulation::user_population() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ChromeUserPopulation.user_population)
+  return _internal_user_population();
+}
+inline void ChromeUserPopulation::_internal_set_user_population(::safe_browsing::ChromeUserPopulation_UserPopulation value) {
+  assert(::safe_browsing::ChromeUserPopulation_UserPopulation_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.user_population_ = value;
+}
+inline void ChromeUserPopulation::set_user_population(::safe_browsing::ChromeUserPopulation_UserPopulation value) {
+  _internal_set_user_population(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ChromeUserPopulation.user_population)
+}
+
+// optional bool is_history_sync_enabled = 2;
+inline bool ChromeUserPopulation::_internal_has_is_history_sync_enabled() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ChromeUserPopulation::has_is_history_sync_enabled() const {
+  return _internal_has_is_history_sync_enabled();
+}
+inline void ChromeUserPopulation::clear_is_history_sync_enabled() {
+  _impl_.is_history_sync_enabled_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool ChromeUserPopulation::_internal_is_history_sync_enabled() const {
+  return _impl_.is_history_sync_enabled_;
+}
+inline bool ChromeUserPopulation::is_history_sync_enabled() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ChromeUserPopulation.is_history_sync_enabled)
+  return _internal_is_history_sync_enabled();
+}
+inline void ChromeUserPopulation::_internal_set_is_history_sync_enabled(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.is_history_sync_enabled_ = value;
+}
+inline void ChromeUserPopulation::set_is_history_sync_enabled(bool value) {
+  _internal_set_is_history_sync_enabled(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ChromeUserPopulation.is_history_sync_enabled)
+}
+
+// repeated string finch_active_groups = 4;
+inline int ChromeUserPopulation::_internal_finch_active_groups_size() const {
+  return _impl_.finch_active_groups_.size();
+}
+inline int ChromeUserPopulation::finch_active_groups_size() const {
+  return _internal_finch_active_groups_size();
+}
+inline void ChromeUserPopulation::clear_finch_active_groups() {
+  _impl_.finch_active_groups_.Clear();
+}
+inline std::string* ChromeUserPopulation::add_finch_active_groups() {
+  std::string* _s = _internal_add_finch_active_groups();
+  // @@protoc_insertion_point(field_add_mutable:safe_browsing.ChromeUserPopulation.finch_active_groups)
+  return _s;
+}
+inline const std::string& ChromeUserPopulation::_internal_finch_active_groups(int index) const {
+  return _impl_.finch_active_groups_.Get(index);
+}
+inline const std::string& ChromeUserPopulation::finch_active_groups(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ChromeUserPopulation.finch_active_groups)
+  return _internal_finch_active_groups(index);
+}
+inline std::string* ChromeUserPopulation::mutable_finch_active_groups(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ChromeUserPopulation.finch_active_groups)
+  return _impl_.finch_active_groups_.Mutable(index);
+}
+inline void ChromeUserPopulation::set_finch_active_groups(int index, const std::string& value) {
+  _impl_.finch_active_groups_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ChromeUserPopulation.finch_active_groups)
+}
+inline void ChromeUserPopulation::set_finch_active_groups(int index, std::string&& value) {
+  _impl_.finch_active_groups_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:safe_browsing.ChromeUserPopulation.finch_active_groups)
+}
+inline void ChromeUserPopulation::set_finch_active_groups(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.finch_active_groups_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ChromeUserPopulation.finch_active_groups)
+}
+inline void ChromeUserPopulation::set_finch_active_groups(int index, const char* value, size_t size) {
+  _impl_.finch_active_groups_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ChromeUserPopulation.finch_active_groups)
+}
+inline std::string* ChromeUserPopulation::_internal_add_finch_active_groups() {
+  return _impl_.finch_active_groups_.Add();
+}
+inline void ChromeUserPopulation::add_finch_active_groups(const std::string& value) {
+  _impl_.finch_active_groups_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ChromeUserPopulation.finch_active_groups)
+}
+inline void ChromeUserPopulation::add_finch_active_groups(std::string&& value) {
+  _impl_.finch_active_groups_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:safe_browsing.ChromeUserPopulation.finch_active_groups)
+}
+inline void ChromeUserPopulation::add_finch_active_groups(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.finch_active_groups_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:safe_browsing.ChromeUserPopulation.finch_active_groups)
+}
+inline void ChromeUserPopulation::add_finch_active_groups(const char* value, size_t size) {
+  _impl_.finch_active_groups_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:safe_browsing.ChromeUserPopulation.finch_active_groups)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ChromeUserPopulation::finch_active_groups() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ChromeUserPopulation.finch_active_groups)
+  return _impl_.finch_active_groups_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ChromeUserPopulation::mutable_finch_active_groups() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ChromeUserPopulation.finch_active_groups)
+  return &_impl_.finch_active_groups_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientPhishingRequest_Feature
+
+// required string name = 1;
+inline bool ClientPhishingRequest_Feature::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientPhishingRequest_Feature::has_name() const {
+  return _internal_has_name();
+}
+inline void ClientPhishingRequest_Feature::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientPhishingRequest_Feature::name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.Feature.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPhishingRequest_Feature::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.Feature.name)
+}
+inline std::string* ClientPhishingRequest_Feature::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.Feature.name)
+  return _s;
+}
+inline const std::string& ClientPhishingRequest_Feature::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void ClientPhishingRequest_Feature::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPhishingRequest_Feature::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPhishingRequest_Feature::release_name() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientPhishingRequest.Feature.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPhishingRequest_Feature::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientPhishingRequest.Feature.name)
+}
+
+// required double value = 2;
+inline bool ClientPhishingRequest_Feature::_internal_has_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientPhishingRequest_Feature::has_value() const {
+  return _internal_has_value();
+}
+inline void ClientPhishingRequest_Feature::clear_value() {
+  _impl_.value_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline double ClientPhishingRequest_Feature::_internal_value() const {
+  return _impl_.value_;
+}
+inline double ClientPhishingRequest_Feature::value() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.Feature.value)
+  return _internal_value();
+}
+inline void ClientPhishingRequest_Feature::_internal_set_value(double value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.value_ = value;
+}
+inline void ClientPhishingRequest_Feature::set_value(double value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.Feature.value)
+}
+
+// -------------------------------------------------------------------
+
+// ClientPhishingRequest
+
+// optional string url = 1;
+inline bool ClientPhishingRequest::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientPhishingRequest::has_url() const {
+  return _internal_has_url();
+}
+inline void ClientPhishingRequest::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientPhishingRequest::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPhishingRequest::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.url)
+}
+inline std::string* ClientPhishingRequest::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.url)
+  return _s;
+}
+inline const std::string& ClientPhishingRequest::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void ClientPhishingRequest::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPhishingRequest::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPhishingRequest::release_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientPhishingRequest.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPhishingRequest::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientPhishingRequest.url)
+}
+
+// optional bytes OBSOLETE_hash_prefix = 10;
+inline bool ClientPhishingRequest::_internal_has_obsolete_hash_prefix() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientPhishingRequest::has_obsolete_hash_prefix() const {
+  return _internal_has_obsolete_hash_prefix();
+}
+inline void ClientPhishingRequest::clear_obsolete_hash_prefix() {
+  _impl_.obsolete_hash_prefix_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientPhishingRequest::obsolete_hash_prefix() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix)
+  return _internal_obsolete_hash_prefix();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPhishingRequest::set_obsolete_hash_prefix(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.obsolete_hash_prefix_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix)
+}
+inline std::string* ClientPhishingRequest::mutable_obsolete_hash_prefix() {
+  std::string* _s = _internal_mutable_obsolete_hash_prefix();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix)
+  return _s;
+}
+inline const std::string& ClientPhishingRequest::_internal_obsolete_hash_prefix() const {
+  return _impl_.obsolete_hash_prefix_.Get();
+}
+inline void ClientPhishingRequest::_internal_set_obsolete_hash_prefix(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.obsolete_hash_prefix_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPhishingRequest::_internal_mutable_obsolete_hash_prefix() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.obsolete_hash_prefix_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPhishingRequest::release_obsolete_hash_prefix() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix)
+  if (!_internal_has_obsolete_hash_prefix()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.obsolete_hash_prefix_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.obsolete_hash_prefix_.IsDefault()) {
+    _impl_.obsolete_hash_prefix_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPhishingRequest::set_allocated_obsolete_hash_prefix(std::string* obsolete_hash_prefix) {
+  if (obsolete_hash_prefix != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.obsolete_hash_prefix_.SetAllocated(obsolete_hash_prefix, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.obsolete_hash_prefix_.IsDefault()) {
+    _impl_.obsolete_hash_prefix_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix)
+}
+
+// required float client_score = 2;
+inline bool ClientPhishingRequest::_internal_has_client_score() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ClientPhishingRequest::has_client_score() const {
+  return _internal_has_client_score();
+}
+inline void ClientPhishingRequest::clear_client_score() {
+  _impl_.client_score_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline float ClientPhishingRequest::_internal_client_score() const {
+  return _impl_.client_score_;
+}
+inline float ClientPhishingRequest::client_score() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.client_score)
+  return _internal_client_score();
+}
+inline void ClientPhishingRequest::_internal_set_client_score(float value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.client_score_ = value;
+}
+inline void ClientPhishingRequest::set_client_score(float value) {
+  _internal_set_client_score(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.client_score)
+}
+
+// optional bool is_phishing = 4;
+inline bool ClientPhishingRequest::_internal_has_is_phishing() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ClientPhishingRequest::has_is_phishing() const {
+  return _internal_has_is_phishing();
+}
+inline void ClientPhishingRequest::clear_is_phishing() {
+  _impl_.is_phishing_ = false;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline bool ClientPhishingRequest::_internal_is_phishing() const {
+  return _impl_.is_phishing_;
+}
+inline bool ClientPhishingRequest::is_phishing() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.is_phishing)
+  return _internal_is_phishing();
+}
+inline void ClientPhishingRequest::_internal_set_is_phishing(bool value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.is_phishing_ = value;
+}
+inline void ClientPhishingRequest::set_is_phishing(bool value) {
+  _internal_set_is_phishing(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.is_phishing)
+}
+
+// repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5;
+inline int ClientPhishingRequest::_internal_feature_map_size() const {
+  return _impl_.feature_map_.size();
+}
+inline int ClientPhishingRequest::feature_map_size() const {
+  return _internal_feature_map_size();
+}
+inline void ClientPhishingRequest::clear_feature_map() {
+  _impl_.feature_map_.Clear();
+}
+inline ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::mutable_feature_map(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.feature_map)
+  return _impl_.feature_map_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >*
+ClientPhishingRequest::mutable_feature_map() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientPhishingRequest.feature_map)
+  return &_impl_.feature_map_;
+}
+inline const ::safe_browsing::ClientPhishingRequest_Feature& ClientPhishingRequest::_internal_feature_map(int index) const {
+  return _impl_.feature_map_.Get(index);
+}
+inline const ::safe_browsing::ClientPhishingRequest_Feature& ClientPhishingRequest::feature_map(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.feature_map)
+  return _internal_feature_map(index);
+}
+inline ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::_internal_add_feature_map() {
+  return _impl_.feature_map_.Add();
+}
+inline ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::add_feature_map() {
+  ::safe_browsing::ClientPhishingRequest_Feature* _add = _internal_add_feature_map();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientPhishingRequest.feature_map)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >&
+ClientPhishingRequest::feature_map() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientPhishingRequest.feature_map)
+  return _impl_.feature_map_;
+}
+
+// optional int32 model_version = 6;
+inline bool ClientPhishingRequest::_internal_has_model_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ClientPhishingRequest::has_model_version() const {
+  return _internal_has_model_version();
+}
+inline void ClientPhishingRequest::clear_model_version() {
+  _impl_.model_version_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline int32_t ClientPhishingRequest::_internal_model_version() const {
+  return _impl_.model_version_;
+}
+inline int32_t ClientPhishingRequest::model_version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.model_version)
+  return _internal_model_version();
+}
+inline void ClientPhishingRequest::_internal_set_model_version(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.model_version_ = value;
+}
+inline void ClientPhishingRequest::set_model_version(int32_t value) {
+  _internal_set_model_version(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.model_version)
+}
+
+// repeated .safe_browsing.ClientPhishingRequest.Feature non_model_feature_map = 8;
+inline int ClientPhishingRequest::_internal_non_model_feature_map_size() const {
+  return _impl_.non_model_feature_map_.size();
+}
+inline int ClientPhishingRequest::non_model_feature_map_size() const {
+  return _internal_non_model_feature_map_size();
+}
+inline void ClientPhishingRequest::clear_non_model_feature_map() {
+  _impl_.non_model_feature_map_.Clear();
+}
+inline ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::mutable_non_model_feature_map(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.non_model_feature_map)
+  return _impl_.non_model_feature_map_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >*
+ClientPhishingRequest::mutable_non_model_feature_map() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientPhishingRequest.non_model_feature_map)
+  return &_impl_.non_model_feature_map_;
+}
+inline const ::safe_browsing::ClientPhishingRequest_Feature& ClientPhishingRequest::_internal_non_model_feature_map(int index) const {
+  return _impl_.non_model_feature_map_.Get(index);
+}
+inline const ::safe_browsing::ClientPhishingRequest_Feature& ClientPhishingRequest::non_model_feature_map(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.non_model_feature_map)
+  return _internal_non_model_feature_map(index);
+}
+inline ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::_internal_add_non_model_feature_map() {
+  return _impl_.non_model_feature_map_.Add();
+}
+inline ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::add_non_model_feature_map() {
+  ::safe_browsing::ClientPhishingRequest_Feature* _add = _internal_add_non_model_feature_map();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientPhishingRequest.non_model_feature_map)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >&
+ClientPhishingRequest::non_model_feature_map() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientPhishingRequest.non_model_feature_map)
+  return _impl_.non_model_feature_map_;
+}
+
+// optional string OBSOLETE_referrer_url = 9;
+inline bool ClientPhishingRequest::_internal_has_obsolete_referrer_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientPhishingRequest::has_obsolete_referrer_url() const {
+  return _internal_has_obsolete_referrer_url();
+}
+inline void ClientPhishingRequest::clear_obsolete_referrer_url() {
+  _impl_.obsolete_referrer_url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientPhishingRequest::obsolete_referrer_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url)
+  return _internal_obsolete_referrer_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPhishingRequest::set_obsolete_referrer_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.obsolete_referrer_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url)
+}
+inline std::string* ClientPhishingRequest::mutable_obsolete_referrer_url() {
+  std::string* _s = _internal_mutable_obsolete_referrer_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url)
+  return _s;
+}
+inline const std::string& ClientPhishingRequest::_internal_obsolete_referrer_url() const {
+  return _impl_.obsolete_referrer_url_.Get();
+}
+inline void ClientPhishingRequest::_internal_set_obsolete_referrer_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.obsolete_referrer_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPhishingRequest::_internal_mutable_obsolete_referrer_url() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.obsolete_referrer_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPhishingRequest::release_obsolete_referrer_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url)
+  if (!_internal_has_obsolete_referrer_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.obsolete_referrer_url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.obsolete_referrer_url_.IsDefault()) {
+    _impl_.obsolete_referrer_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPhishingRequest::set_allocated_obsolete_referrer_url(std::string* obsolete_referrer_url) {
+  if (obsolete_referrer_url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.obsolete_referrer_url_.SetAllocated(obsolete_referrer_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.obsolete_referrer_url_.IsDefault()) {
+    _impl_.obsolete_referrer_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url)
+}
+
+// repeated uint32 shingle_hashes = 12 [packed = true];
+inline int ClientPhishingRequest::_internal_shingle_hashes_size() const {
+  return _impl_.shingle_hashes_.size();
+}
+inline int ClientPhishingRequest::shingle_hashes_size() const {
+  return _internal_shingle_hashes_size();
+}
+inline void ClientPhishingRequest::clear_shingle_hashes() {
+  _impl_.shingle_hashes_.Clear();
+}
+inline uint32_t ClientPhishingRequest::_internal_shingle_hashes(int index) const {
+  return _impl_.shingle_hashes_.Get(index);
+}
+inline uint32_t ClientPhishingRequest::shingle_hashes(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.shingle_hashes)
+  return _internal_shingle_hashes(index);
+}
+inline void ClientPhishingRequest::set_shingle_hashes(int index, uint32_t value) {
+  _impl_.shingle_hashes_.Set(index, value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.shingle_hashes)
+}
+inline void ClientPhishingRequest::_internal_add_shingle_hashes(uint32_t value) {
+  _impl_.shingle_hashes_.Add(value);
+}
+inline void ClientPhishingRequest::add_shingle_hashes(uint32_t value) {
+  _internal_add_shingle_hashes(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientPhishingRequest.shingle_hashes)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+ClientPhishingRequest::_internal_shingle_hashes() const {
+  return _impl_.shingle_hashes_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+ClientPhishingRequest::shingle_hashes() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientPhishingRequest.shingle_hashes)
+  return _internal_shingle_hashes();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+ClientPhishingRequest::_internal_mutable_shingle_hashes() {
+  return &_impl_.shingle_hashes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+ClientPhishingRequest::mutable_shingle_hashes() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientPhishingRequest.shingle_hashes)
+  return _internal_mutable_shingle_hashes();
+}
+
+// optional string model_filename = 13;
+inline bool ClientPhishingRequest::_internal_has_model_filename() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientPhishingRequest::has_model_filename() const {
+  return _internal_has_model_filename();
+}
+inline void ClientPhishingRequest::clear_model_filename() {
+  _impl_.model_filename_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ClientPhishingRequest::model_filename() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.model_filename)
+  return _internal_model_filename();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientPhishingRequest::set_model_filename(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.model_filename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.model_filename)
+}
+inline std::string* ClientPhishingRequest::mutable_model_filename() {
+  std::string* _s = _internal_mutable_model_filename();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.model_filename)
+  return _s;
+}
+inline const std::string& ClientPhishingRequest::_internal_model_filename() const {
+  return _impl_.model_filename_.Get();
+}
+inline void ClientPhishingRequest::_internal_set_model_filename(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.model_filename_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientPhishingRequest::_internal_mutable_model_filename() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.model_filename_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientPhishingRequest::release_model_filename() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientPhishingRequest.model_filename)
+  if (!_internal_has_model_filename()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.model_filename_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.model_filename_.IsDefault()) {
+    _impl_.model_filename_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientPhishingRequest::set_allocated_model_filename(std::string* model_filename) {
+  if (model_filename != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.model_filename_.SetAllocated(model_filename, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.model_filename_.IsDefault()) {
+    _impl_.model_filename_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientPhishingRequest.model_filename)
+}
+
+// optional .safe_browsing.ChromeUserPopulation population = 14;
+inline bool ClientPhishingRequest::_internal_has_population() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.population_ != nullptr);
+  return value;
+}
+inline bool ClientPhishingRequest::has_population() const {
+  return _internal_has_population();
+}
+inline void ClientPhishingRequest::clear_population() {
+  if (_impl_.population_ != nullptr) _impl_.population_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::safe_browsing::ChromeUserPopulation& ClientPhishingRequest::_internal_population() const {
+  const ::safe_browsing::ChromeUserPopulation* p = _impl_.population_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ChromeUserPopulation&>(
+      ::safe_browsing::_ChromeUserPopulation_default_instance_);
+}
+inline const ::safe_browsing::ChromeUserPopulation& ClientPhishingRequest::population() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.population)
+  return _internal_population();
+}
+inline void ClientPhishingRequest::unsafe_arena_set_allocated_population(
+    ::safe_browsing::ChromeUserPopulation* population) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.population_);
+  }
+  _impl_.population_ = population;
+  if (population) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientPhishingRequest.population)
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientPhishingRequest::release_population() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::safe_browsing::ChromeUserPopulation* temp = _impl_.population_;
+  _impl_.population_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientPhishingRequest::unsafe_arena_release_population() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientPhishingRequest.population)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::safe_browsing::ChromeUserPopulation* temp = _impl_.population_;
+  _impl_.population_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientPhishingRequest::_internal_mutable_population() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.population_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ChromeUserPopulation>(GetArenaForAllocation());
+    _impl_.population_ = p;
+  }
+  return _impl_.population_;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientPhishingRequest::mutable_population() {
+  ::safe_browsing::ChromeUserPopulation* _msg = _internal_mutable_population();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.population)
+  return _msg;
+}
+inline void ClientPhishingRequest::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.population_;
+  }
+  if (population) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(population);
+    if (message_arena != submessage_arena) {
+      population = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, population, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.population_ = population;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientPhishingRequest.population)
+}
+
+// -------------------------------------------------------------------
+
+// ClientPhishingResponse
+
+// required bool phishy = 1;
+inline bool ClientPhishingResponse::_internal_has_phishy() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientPhishingResponse::has_phishy() const {
+  return _internal_has_phishy();
+}
+inline void ClientPhishingResponse::clear_phishy() {
+  _impl_.phishy_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool ClientPhishingResponse::_internal_phishy() const {
+  return _impl_.phishy_;
+}
+inline bool ClientPhishingResponse::phishy() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingResponse.phishy)
+  return _internal_phishy();
+}
+inline void ClientPhishingResponse::_internal_set_phishy(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.phishy_ = value;
+}
+inline void ClientPhishingResponse::set_phishy(bool value) {
+  _internal_set_phishy(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingResponse.phishy)
+}
+
+// repeated string OBSOLETE_whitelist_expression = 2;
+inline int ClientPhishingResponse::_internal_obsolete_whitelist_expression_size() const {
+  return _impl_.obsolete_whitelist_expression_.size();
+}
+inline int ClientPhishingResponse::obsolete_whitelist_expression_size() const {
+  return _internal_obsolete_whitelist_expression_size();
+}
+inline void ClientPhishingResponse::clear_obsolete_whitelist_expression() {
+  _impl_.obsolete_whitelist_expression_.Clear();
+}
+inline std::string* ClientPhishingResponse::add_obsolete_whitelist_expression() {
+  std::string* _s = _internal_add_obsolete_whitelist_expression();
+  // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+  return _s;
+}
+inline const std::string& ClientPhishingResponse::_internal_obsolete_whitelist_expression(int index) const {
+  return _impl_.obsolete_whitelist_expression_.Get(index);
+}
+inline const std::string& ClientPhishingResponse::obsolete_whitelist_expression(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+  return _internal_obsolete_whitelist_expression(index);
+}
+inline std::string* ClientPhishingResponse::mutable_obsolete_whitelist_expression(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+  return _impl_.obsolete_whitelist_expression_.Mutable(index);
+}
+inline void ClientPhishingResponse::set_obsolete_whitelist_expression(int index, const std::string& value) {
+  _impl_.obsolete_whitelist_expression_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+}
+inline void ClientPhishingResponse::set_obsolete_whitelist_expression(int index, std::string&& value) {
+  _impl_.obsolete_whitelist_expression_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+}
+inline void ClientPhishingResponse::set_obsolete_whitelist_expression(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.obsolete_whitelist_expression_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+}
+inline void ClientPhishingResponse::set_obsolete_whitelist_expression(int index, const char* value, size_t size) {
+  _impl_.obsolete_whitelist_expression_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+}
+inline std::string* ClientPhishingResponse::_internal_add_obsolete_whitelist_expression() {
+  return _impl_.obsolete_whitelist_expression_.Add();
+}
+inline void ClientPhishingResponse::add_obsolete_whitelist_expression(const std::string& value) {
+  _impl_.obsolete_whitelist_expression_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+}
+inline void ClientPhishingResponse::add_obsolete_whitelist_expression(std::string&& value) {
+  _impl_.obsolete_whitelist_expression_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+}
+inline void ClientPhishingResponse::add_obsolete_whitelist_expression(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.obsolete_whitelist_expression_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+}
+inline void ClientPhishingResponse::add_obsolete_whitelist_expression(const char* value, size_t size) {
+  _impl_.obsolete_whitelist_expression_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ClientPhishingResponse::obsolete_whitelist_expression() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+  return _impl_.obsolete_whitelist_expression_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ClientPhishingResponse::mutable_obsolete_whitelist_expression() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+  return &_impl_.obsolete_whitelist_expression_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientMalwareRequest_UrlInfo
+
+// required string ip = 1;
+inline bool ClientMalwareRequest_UrlInfo::_internal_has_ip() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientMalwareRequest_UrlInfo::has_ip() const {
+  return _internal_has_ip();
+}
+inline void ClientMalwareRequest_UrlInfo::clear_ip() {
+  _impl_.ip_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientMalwareRequest_UrlInfo::ip() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.UrlInfo.ip)
+  return _internal_ip();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientMalwareRequest_UrlInfo::set_ip(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.ip_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.ip)
+}
+inline std::string* ClientMalwareRequest_UrlInfo::mutable_ip() {
+  std::string* _s = _internal_mutable_ip();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.UrlInfo.ip)
+  return _s;
+}
+inline const std::string& ClientMalwareRequest_UrlInfo::_internal_ip() const {
+  return _impl_.ip_.Get();
+}
+inline void ClientMalwareRequest_UrlInfo::_internal_set_ip(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.ip_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientMalwareRequest_UrlInfo::_internal_mutable_ip() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.ip_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientMalwareRequest_UrlInfo::release_ip() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.UrlInfo.ip)
+  if (!_internal_has_ip()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.ip_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ip_.IsDefault()) {
+    _impl_.ip_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientMalwareRequest_UrlInfo::set_allocated_ip(std::string* ip) {
+  if (ip != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.ip_.SetAllocated(ip, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ip_.IsDefault()) {
+    _impl_.ip_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.UrlInfo.ip)
+}
+
+// required string url = 2;
+inline bool ClientMalwareRequest_UrlInfo::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientMalwareRequest_UrlInfo::has_url() const {
+  return _internal_has_url();
+}
+inline void ClientMalwareRequest_UrlInfo::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientMalwareRequest_UrlInfo::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.UrlInfo.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientMalwareRequest_UrlInfo::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.url)
+}
+inline std::string* ClientMalwareRequest_UrlInfo::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.UrlInfo.url)
+  return _s;
+}
+inline const std::string& ClientMalwareRequest_UrlInfo::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void ClientMalwareRequest_UrlInfo::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientMalwareRequest_UrlInfo::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientMalwareRequest_UrlInfo::release_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.UrlInfo.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientMalwareRequest_UrlInfo::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.UrlInfo.url)
+}
+
+// optional string method = 3;
+inline bool ClientMalwareRequest_UrlInfo::_internal_has_method() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientMalwareRequest_UrlInfo::has_method() const {
+  return _internal_has_method();
+}
+inline void ClientMalwareRequest_UrlInfo::clear_method() {
+  _impl_.method_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientMalwareRequest_UrlInfo::method() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.UrlInfo.method)
+  return _internal_method();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientMalwareRequest_UrlInfo::set_method(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.method_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.method)
+}
+inline std::string* ClientMalwareRequest_UrlInfo::mutable_method() {
+  std::string* _s = _internal_mutable_method();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.UrlInfo.method)
+  return _s;
+}
+inline const std::string& ClientMalwareRequest_UrlInfo::_internal_method() const {
+  return _impl_.method_.Get();
+}
+inline void ClientMalwareRequest_UrlInfo::_internal_set_method(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.method_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientMalwareRequest_UrlInfo::_internal_mutable_method() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.method_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientMalwareRequest_UrlInfo::release_method() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.UrlInfo.method)
+  if (!_internal_has_method()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.method_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.method_.IsDefault()) {
+    _impl_.method_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientMalwareRequest_UrlInfo::set_allocated_method(std::string* method) {
+  if (method != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.method_.SetAllocated(method, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.method_.IsDefault()) {
+    _impl_.method_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.UrlInfo.method)
+}
+
+// optional string referrer = 4;
+inline bool ClientMalwareRequest_UrlInfo::_internal_has_referrer() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientMalwareRequest_UrlInfo::has_referrer() const {
+  return _internal_has_referrer();
+}
+inline void ClientMalwareRequest_UrlInfo::clear_referrer() {
+  _impl_.referrer_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ClientMalwareRequest_UrlInfo::referrer() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.UrlInfo.referrer)
+  return _internal_referrer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientMalwareRequest_UrlInfo::set_referrer(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.referrer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.referrer)
+}
+inline std::string* ClientMalwareRequest_UrlInfo::mutable_referrer() {
+  std::string* _s = _internal_mutable_referrer();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.UrlInfo.referrer)
+  return _s;
+}
+inline const std::string& ClientMalwareRequest_UrlInfo::_internal_referrer() const {
+  return _impl_.referrer_.Get();
+}
+inline void ClientMalwareRequest_UrlInfo::_internal_set_referrer(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.referrer_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientMalwareRequest_UrlInfo::_internal_mutable_referrer() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.referrer_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientMalwareRequest_UrlInfo::release_referrer() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.UrlInfo.referrer)
+  if (!_internal_has_referrer()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.referrer_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_.IsDefault()) {
+    _impl_.referrer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientMalwareRequest_UrlInfo::set_allocated_referrer(std::string* referrer) {
+  if (referrer != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.referrer_.SetAllocated(referrer, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_.IsDefault()) {
+    _impl_.referrer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.UrlInfo.referrer)
+}
+
+// optional int32 resource_type = 5;
+inline bool ClientMalwareRequest_UrlInfo::_internal_has_resource_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientMalwareRequest_UrlInfo::has_resource_type() const {
+  return _internal_has_resource_type();
+}
+inline void ClientMalwareRequest_UrlInfo::clear_resource_type() {
+  _impl_.resource_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline int32_t ClientMalwareRequest_UrlInfo::_internal_resource_type() const {
+  return _impl_.resource_type_;
+}
+inline int32_t ClientMalwareRequest_UrlInfo::resource_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.UrlInfo.resource_type)
+  return _internal_resource_type();
+}
+inline void ClientMalwareRequest_UrlInfo::_internal_set_resource_type(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.resource_type_ = value;
+}
+inline void ClientMalwareRequest_UrlInfo::set_resource_type(int32_t value) {
+  _internal_set_resource_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.resource_type)
+}
+
+// -------------------------------------------------------------------
+
+// ClientMalwareRequest
+
+// required string url = 1;
+inline bool ClientMalwareRequest::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientMalwareRequest::has_url() const {
+  return _internal_has_url();
+}
+inline void ClientMalwareRequest::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientMalwareRequest::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientMalwareRequest::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.url)
+}
+inline std::string* ClientMalwareRequest::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.url)
+  return _s;
+}
+inline const std::string& ClientMalwareRequest::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void ClientMalwareRequest::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientMalwareRequest::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientMalwareRequest::release_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientMalwareRequest::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.url)
+}
+
+// optional string referrer_url = 4;
+inline bool ClientMalwareRequest::_internal_has_referrer_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientMalwareRequest::has_referrer_url() const {
+  return _internal_has_referrer_url();
+}
+inline void ClientMalwareRequest::clear_referrer_url() {
+  _impl_.referrer_url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientMalwareRequest::referrer_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.referrer_url)
+  return _internal_referrer_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientMalwareRequest::set_referrer_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.referrer_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.referrer_url)
+}
+inline std::string* ClientMalwareRequest::mutable_referrer_url() {
+  std::string* _s = _internal_mutable_referrer_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.referrer_url)
+  return _s;
+}
+inline const std::string& ClientMalwareRequest::_internal_referrer_url() const {
+  return _impl_.referrer_url_.Get();
+}
+inline void ClientMalwareRequest::_internal_set_referrer_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.referrer_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientMalwareRequest::_internal_mutable_referrer_url() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.referrer_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientMalwareRequest::release_referrer_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.referrer_url)
+  if (!_internal_has_referrer_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.referrer_url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_url_.IsDefault()) {
+    _impl_.referrer_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientMalwareRequest::set_allocated_referrer_url(std::string* referrer_url) {
+  if (referrer_url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.referrer_url_.SetAllocated(referrer_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_url_.IsDefault()) {
+    _impl_.referrer_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.referrer_url)
+}
+
+// repeated .safe_browsing.ClientMalwareRequest.UrlInfo bad_ip_url_info = 7;
+inline int ClientMalwareRequest::_internal_bad_ip_url_info_size() const {
+  return _impl_.bad_ip_url_info_.size();
+}
+inline int ClientMalwareRequest::bad_ip_url_info_size() const {
+  return _internal_bad_ip_url_info_size();
+}
+inline void ClientMalwareRequest::clear_bad_ip_url_info() {
+  _impl_.bad_ip_url_info_.Clear();
+}
+inline ::safe_browsing::ClientMalwareRequest_UrlInfo* ClientMalwareRequest::mutable_bad_ip_url_info(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.bad_ip_url_info)
+  return _impl_.bad_ip_url_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_UrlInfo >*
+ClientMalwareRequest::mutable_bad_ip_url_info() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientMalwareRequest.bad_ip_url_info)
+  return &_impl_.bad_ip_url_info_;
+}
+inline const ::safe_browsing::ClientMalwareRequest_UrlInfo& ClientMalwareRequest::_internal_bad_ip_url_info(int index) const {
+  return _impl_.bad_ip_url_info_.Get(index);
+}
+inline const ::safe_browsing::ClientMalwareRequest_UrlInfo& ClientMalwareRequest::bad_ip_url_info(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.bad_ip_url_info)
+  return _internal_bad_ip_url_info(index);
+}
+inline ::safe_browsing::ClientMalwareRequest_UrlInfo* ClientMalwareRequest::_internal_add_bad_ip_url_info() {
+  return _impl_.bad_ip_url_info_.Add();
+}
+inline ::safe_browsing::ClientMalwareRequest_UrlInfo* ClientMalwareRequest::add_bad_ip_url_info() {
+  ::safe_browsing::ClientMalwareRequest_UrlInfo* _add = _internal_add_bad_ip_url_info();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientMalwareRequest.bad_ip_url_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_UrlInfo >&
+ClientMalwareRequest::bad_ip_url_info() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientMalwareRequest.bad_ip_url_info)
+  return _impl_.bad_ip_url_info_;
+}
+
+// optional .safe_browsing.ChromeUserPopulation population = 9;
+inline bool ClientMalwareRequest::_internal_has_population() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.population_ != nullptr);
+  return value;
+}
+inline bool ClientMalwareRequest::has_population() const {
+  return _internal_has_population();
+}
+inline void ClientMalwareRequest::clear_population() {
+  if (_impl_.population_ != nullptr) _impl_.population_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::safe_browsing::ChromeUserPopulation& ClientMalwareRequest::_internal_population() const {
+  const ::safe_browsing::ChromeUserPopulation* p = _impl_.population_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ChromeUserPopulation&>(
+      ::safe_browsing::_ChromeUserPopulation_default_instance_);
+}
+inline const ::safe_browsing::ChromeUserPopulation& ClientMalwareRequest::population() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.population)
+  return _internal_population();
+}
+inline void ClientMalwareRequest::unsafe_arena_set_allocated_population(
+    ::safe_browsing::ChromeUserPopulation* population) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.population_);
+  }
+  _impl_.population_ = population;
+  if (population) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientMalwareRequest.population)
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientMalwareRequest::release_population() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ChromeUserPopulation* temp = _impl_.population_;
+  _impl_.population_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientMalwareRequest::unsafe_arena_release_population() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.population)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ChromeUserPopulation* temp = _impl_.population_;
+  _impl_.population_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientMalwareRequest::_internal_mutable_population() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.population_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ChromeUserPopulation>(GetArenaForAllocation());
+    _impl_.population_ = p;
+  }
+  return _impl_.population_;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientMalwareRequest::mutable_population() {
+  ::safe_browsing::ChromeUserPopulation* _msg = _internal_mutable_population();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.population)
+  return _msg;
+}
+inline void ClientMalwareRequest::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.population_;
+  }
+  if (population) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(population);
+    if (message_arena != submessage_arena) {
+      population = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, population, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.population_ = population;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.population)
+}
+
+// -------------------------------------------------------------------
+
+// LoginReputationClientRequest_Frame_Form
+
+// optional string action_url = 1;
+inline bool LoginReputationClientRequest_Frame_Form::_internal_has_action_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LoginReputationClientRequest_Frame_Form::has_action_url() const {
+  return _internal_has_action_url();
+}
+inline void LoginReputationClientRequest_Frame_Form::clear_action_url() {
+  _impl_.action_url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LoginReputationClientRequest_Frame_Form::action_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.Frame.Form.action_url)
+  return _internal_action_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LoginReputationClientRequest_Frame_Form::set_action_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.action_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.Frame.Form.action_url)
+}
+inline std::string* LoginReputationClientRequest_Frame_Form::mutable_action_url() {
+  std::string* _s = _internal_mutable_action_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.Frame.Form.action_url)
+  return _s;
+}
+inline const std::string& LoginReputationClientRequest_Frame_Form::_internal_action_url() const {
+  return _impl_.action_url_.Get();
+}
+inline void LoginReputationClientRequest_Frame_Form::_internal_set_action_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.action_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* LoginReputationClientRequest_Frame_Form::_internal_mutable_action_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.action_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* LoginReputationClientRequest_Frame_Form::release_action_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.LoginReputationClientRequest.Frame.Form.action_url)
+  if (!_internal_has_action_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.action_url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.action_url_.IsDefault()) {
+    _impl_.action_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void LoginReputationClientRequest_Frame_Form::set_allocated_action_url(std::string* action_url) {
+  if (action_url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.action_url_.SetAllocated(action_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.action_url_.IsDefault()) {
+    _impl_.action_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.LoginReputationClientRequest.Frame.Form.action_url)
+}
+
+// optional bool has_password_field = 2;
+inline bool LoginReputationClientRequest_Frame_Form::_internal_has_has_password_field() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LoginReputationClientRequest_Frame_Form::has_has_password_field() const {
+  return _internal_has_has_password_field();
+}
+inline void LoginReputationClientRequest_Frame_Form::clear_has_password_field() {
+  _impl_.has_password_field_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool LoginReputationClientRequest_Frame_Form::_internal_has_password_field() const {
+  return _impl_.has_password_field_;
+}
+inline bool LoginReputationClientRequest_Frame_Form::has_password_field() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.Frame.Form.has_password_field)
+  return _internal_has_password_field();
+}
+inline void LoginReputationClientRequest_Frame_Form::_internal_set_has_password_field(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.has_password_field_ = value;
+}
+inline void LoginReputationClientRequest_Frame_Form::set_has_password_field(bool value) {
+  _internal_set_has_password_field(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.Frame.Form.has_password_field)
+}
+
+// -------------------------------------------------------------------
+
+// LoginReputationClientRequest_Frame
+
+// optional int32 frame_index = 1;
+inline bool LoginReputationClientRequest_Frame::_internal_has_frame_index() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LoginReputationClientRequest_Frame::has_frame_index() const {
+  return _internal_has_frame_index();
+}
+inline void LoginReputationClientRequest_Frame::clear_frame_index() {
+  _impl_.frame_index_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t LoginReputationClientRequest_Frame::_internal_frame_index() const {
+  return _impl_.frame_index_;
+}
+inline int32_t LoginReputationClientRequest_Frame::frame_index() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.Frame.frame_index)
+  return _internal_frame_index();
+}
+inline void LoginReputationClientRequest_Frame::_internal_set_frame_index(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.frame_index_ = value;
+}
+inline void LoginReputationClientRequest_Frame::set_frame_index(int32_t value) {
+  _internal_set_frame_index(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.Frame.frame_index)
+}
+
+// optional int32 parent_frame_index = 2;
+inline bool LoginReputationClientRequest_Frame::_internal_has_parent_frame_index() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool LoginReputationClientRequest_Frame::has_parent_frame_index() const {
+  return _internal_has_parent_frame_index();
+}
+inline void LoginReputationClientRequest_Frame::clear_parent_frame_index() {
+  _impl_.parent_frame_index_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t LoginReputationClientRequest_Frame::_internal_parent_frame_index() const {
+  return _impl_.parent_frame_index_;
+}
+inline int32_t LoginReputationClientRequest_Frame::parent_frame_index() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.Frame.parent_frame_index)
+  return _internal_parent_frame_index();
+}
+inline void LoginReputationClientRequest_Frame::_internal_set_parent_frame_index(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.parent_frame_index_ = value;
+}
+inline void LoginReputationClientRequest_Frame::set_parent_frame_index(int32_t value) {
+  _internal_set_parent_frame_index(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.Frame.parent_frame_index)
+}
+
+// optional string url = 3;
+inline bool LoginReputationClientRequest_Frame::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LoginReputationClientRequest_Frame::has_url() const {
+  return _internal_has_url();
+}
+inline void LoginReputationClientRequest_Frame::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LoginReputationClientRequest_Frame::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.Frame.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LoginReputationClientRequest_Frame::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.Frame.url)
+}
+inline std::string* LoginReputationClientRequest_Frame::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.Frame.url)
+  return _s;
+}
+inline const std::string& LoginReputationClientRequest_Frame::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void LoginReputationClientRequest_Frame::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* LoginReputationClientRequest_Frame::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* LoginReputationClientRequest_Frame::release_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.LoginReputationClientRequest.Frame.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void LoginReputationClientRequest_Frame::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.LoginReputationClientRequest.Frame.url)
+}
+
+// optional bool has_password_field = 4;
+inline bool LoginReputationClientRequest_Frame::_internal_has_has_password_field() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool LoginReputationClientRequest_Frame::has_has_password_field() const {
+  return _internal_has_has_password_field();
+}
+inline void LoginReputationClientRequest_Frame::clear_has_password_field() {
+  _impl_.has_password_field_ = false;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline bool LoginReputationClientRequest_Frame::_internal_has_password_field() const {
+  return _impl_.has_password_field_;
+}
+inline bool LoginReputationClientRequest_Frame::has_password_field() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.Frame.has_password_field)
+  return _internal_has_password_field();
+}
+inline void LoginReputationClientRequest_Frame::_internal_set_has_password_field(bool value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.has_password_field_ = value;
+}
+inline void LoginReputationClientRequest_Frame::set_has_password_field(bool value) {
+  _internal_set_has_password_field(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.Frame.has_password_field)
+}
+
+// repeated .safe_browsing.ReferrerChainEntry referrer_chain = 5;
+inline int LoginReputationClientRequest_Frame::_internal_referrer_chain_size() const {
+  return _impl_.referrer_chain_.size();
+}
+inline int LoginReputationClientRequest_Frame::referrer_chain_size() const {
+  return _internal_referrer_chain_size();
+}
+inline void LoginReputationClientRequest_Frame::clear_referrer_chain() {
+  _impl_.referrer_chain_.Clear();
+}
+inline ::safe_browsing::ReferrerChainEntry* LoginReputationClientRequest_Frame::mutable_referrer_chain(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.Frame.referrer_chain)
+  return _impl_.referrer_chain_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry >*
+LoginReputationClientRequest_Frame::mutable_referrer_chain() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.LoginReputationClientRequest.Frame.referrer_chain)
+  return &_impl_.referrer_chain_;
+}
+inline const ::safe_browsing::ReferrerChainEntry& LoginReputationClientRequest_Frame::_internal_referrer_chain(int index) const {
+  return _impl_.referrer_chain_.Get(index);
+}
+inline const ::safe_browsing::ReferrerChainEntry& LoginReputationClientRequest_Frame::referrer_chain(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.Frame.referrer_chain)
+  return _internal_referrer_chain(index);
+}
+inline ::safe_browsing::ReferrerChainEntry* LoginReputationClientRequest_Frame::_internal_add_referrer_chain() {
+  return _impl_.referrer_chain_.Add();
+}
+inline ::safe_browsing::ReferrerChainEntry* LoginReputationClientRequest_Frame::add_referrer_chain() {
+  ::safe_browsing::ReferrerChainEntry* _add = _internal_add_referrer_chain();
+  // @@protoc_insertion_point(field_add:safe_browsing.LoginReputationClientRequest.Frame.referrer_chain)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry >&
+LoginReputationClientRequest_Frame::referrer_chain() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.LoginReputationClientRequest.Frame.referrer_chain)
+  return _impl_.referrer_chain_;
+}
+
+// repeated .safe_browsing.LoginReputationClientRequest.Frame.Form forms = 6;
+inline int LoginReputationClientRequest_Frame::_internal_forms_size() const {
+  return _impl_.forms_.size();
+}
+inline int LoginReputationClientRequest_Frame::forms_size() const {
+  return _internal_forms_size();
+}
+inline void LoginReputationClientRequest_Frame::clear_forms() {
+  _impl_.forms_.Clear();
+}
+inline ::safe_browsing::LoginReputationClientRequest_Frame_Form* LoginReputationClientRequest_Frame::mutable_forms(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.Frame.forms)
+  return _impl_.forms_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::LoginReputationClientRequest_Frame_Form >*
+LoginReputationClientRequest_Frame::mutable_forms() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.LoginReputationClientRequest.Frame.forms)
+  return &_impl_.forms_;
+}
+inline const ::safe_browsing::LoginReputationClientRequest_Frame_Form& LoginReputationClientRequest_Frame::_internal_forms(int index) const {
+  return _impl_.forms_.Get(index);
+}
+inline const ::safe_browsing::LoginReputationClientRequest_Frame_Form& LoginReputationClientRequest_Frame::forms(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.Frame.forms)
+  return _internal_forms(index);
+}
+inline ::safe_browsing::LoginReputationClientRequest_Frame_Form* LoginReputationClientRequest_Frame::_internal_add_forms() {
+  return _impl_.forms_.Add();
+}
+inline ::safe_browsing::LoginReputationClientRequest_Frame_Form* LoginReputationClientRequest_Frame::add_forms() {
+  ::safe_browsing::LoginReputationClientRequest_Frame_Form* _add = _internal_add_forms();
+  // @@protoc_insertion_point(field_add:safe_browsing.LoginReputationClientRequest.Frame.forms)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::LoginReputationClientRequest_Frame_Form >&
+LoginReputationClientRequest_Frame::forms() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.LoginReputationClientRequest.Frame.forms)
+  return _impl_.forms_;
+}
+
+// -------------------------------------------------------------------
+
+// LoginReputationClientRequest_PasswordReuseEvent
+
+// repeated string domains_matching_password = 1;
+inline int LoginReputationClientRequest_PasswordReuseEvent::_internal_domains_matching_password_size() const {
+  return _impl_.domains_matching_password_.size();
+}
+inline int LoginReputationClientRequest_PasswordReuseEvent::domains_matching_password_size() const {
+  return _internal_domains_matching_password_size();
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::clear_domains_matching_password() {
+  _impl_.domains_matching_password_.Clear();
+}
+inline std::string* LoginReputationClientRequest_PasswordReuseEvent::add_domains_matching_password() {
+  std::string* _s = _internal_add_domains_matching_password();
+  // @@protoc_insertion_point(field_add_mutable:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password)
+  return _s;
+}
+inline const std::string& LoginReputationClientRequest_PasswordReuseEvent::_internal_domains_matching_password(int index) const {
+  return _impl_.domains_matching_password_.Get(index);
+}
+inline const std::string& LoginReputationClientRequest_PasswordReuseEvent::domains_matching_password(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password)
+  return _internal_domains_matching_password(index);
+}
+inline std::string* LoginReputationClientRequest_PasswordReuseEvent::mutable_domains_matching_password(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password)
+  return _impl_.domains_matching_password_.Mutable(index);
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::set_domains_matching_password(int index, const std::string& value) {
+  _impl_.domains_matching_password_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password)
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::set_domains_matching_password(int index, std::string&& value) {
+  _impl_.domains_matching_password_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password)
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::set_domains_matching_password(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.domains_matching_password_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password)
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::set_domains_matching_password(int index, const char* value, size_t size) {
+  _impl_.domains_matching_password_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password)
+}
+inline std::string* LoginReputationClientRequest_PasswordReuseEvent::_internal_add_domains_matching_password() {
+  return _impl_.domains_matching_password_.Add();
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::add_domains_matching_password(const std::string& value) {
+  _impl_.domains_matching_password_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password)
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::add_domains_matching_password(std::string&& value) {
+  _impl_.domains_matching_password_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password)
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::add_domains_matching_password(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.domains_matching_password_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password)
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::add_domains_matching_password(const char* value, size_t size) {
+  _impl_.domains_matching_password_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+LoginReputationClientRequest_PasswordReuseEvent::domains_matching_password() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password)
+  return _impl_.domains_matching_password_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+LoginReputationClientRequest_PasswordReuseEvent::mutable_domains_matching_password() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password)
+  return &_impl_.domains_matching_password_;
+}
+
+// optional int32 frame_id = 2;
+inline bool LoginReputationClientRequest_PasswordReuseEvent::_internal_has_frame_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LoginReputationClientRequest_PasswordReuseEvent::has_frame_id() const {
+  return _internal_has_frame_id();
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::clear_frame_id() {
+  _impl_.frame_id_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int32_t LoginReputationClientRequest_PasswordReuseEvent::_internal_frame_id() const {
+  return _impl_.frame_id_;
+}
+inline int32_t LoginReputationClientRequest_PasswordReuseEvent::frame_id() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.frame_id)
+  return _internal_frame_id();
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::_internal_set_frame_id(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.frame_id_ = value;
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::set_frame_id(int32_t value) {
+  _internal_set_frame_id(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.frame_id)
+}
+
+// optional bool is_chrome_signin_password = 3;
+inline bool LoginReputationClientRequest_PasswordReuseEvent::_internal_has_is_chrome_signin_password() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LoginReputationClientRequest_PasswordReuseEvent::has_is_chrome_signin_password() const {
+  return _internal_has_is_chrome_signin_password();
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::clear_is_chrome_signin_password() {
+  _impl_.is_chrome_signin_password_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool LoginReputationClientRequest_PasswordReuseEvent::_internal_is_chrome_signin_password() const {
+  return _impl_.is_chrome_signin_password_;
+}
+inline bool LoginReputationClientRequest_PasswordReuseEvent::is_chrome_signin_password() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.is_chrome_signin_password)
+  return _internal_is_chrome_signin_password();
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::_internal_set_is_chrome_signin_password(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.is_chrome_signin_password_ = value;
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::set_is_chrome_signin_password(bool value) {
+  _internal_set_is_chrome_signin_password(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.is_chrome_signin_password)
+}
+
+// optional .safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.SyncAccountType sync_account_type = 4;
+inline bool LoginReputationClientRequest_PasswordReuseEvent::_internal_has_sync_account_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool LoginReputationClientRequest_PasswordReuseEvent::has_sync_account_type() const {
+  return _internal_has_sync_account_type();
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::clear_sync_account_type() {
+  _impl_.sync_account_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType LoginReputationClientRequest_PasswordReuseEvent::_internal_sync_account_type() const {
+  return static_cast< ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType >(_impl_.sync_account_type_);
+}
+inline ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType LoginReputationClientRequest_PasswordReuseEvent::sync_account_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.sync_account_type)
+  return _internal_sync_account_type();
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::_internal_set_sync_account_type(::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType value) {
+  assert(::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.sync_account_type_ = value;
+}
+inline void LoginReputationClientRequest_PasswordReuseEvent::set_sync_account_type(::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType value) {
+  _internal_set_sync_account_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.sync_account_type)
+}
+
+// -------------------------------------------------------------------
+
+// LoginReputationClientRequest
+
+// optional string page_url = 1;
+inline bool LoginReputationClientRequest::_internal_has_page_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LoginReputationClientRequest::has_page_url() const {
+  return _internal_has_page_url();
+}
+inline void LoginReputationClientRequest::clear_page_url() {
+  _impl_.page_url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LoginReputationClientRequest::page_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.page_url)
+  return _internal_page_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LoginReputationClientRequest::set_page_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.page_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.page_url)
+}
+inline std::string* LoginReputationClientRequest::mutable_page_url() {
+  std::string* _s = _internal_mutable_page_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.page_url)
+  return _s;
+}
+inline const std::string& LoginReputationClientRequest::_internal_page_url() const {
+  return _impl_.page_url_.Get();
+}
+inline void LoginReputationClientRequest::_internal_set_page_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.page_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* LoginReputationClientRequest::_internal_mutable_page_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.page_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* LoginReputationClientRequest::release_page_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.LoginReputationClientRequest.page_url)
+  if (!_internal_has_page_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.page_url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.page_url_.IsDefault()) {
+    _impl_.page_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void LoginReputationClientRequest::set_allocated_page_url(std::string* page_url) {
+  if (page_url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.page_url_.SetAllocated(page_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.page_url_.IsDefault()) {
+    _impl_.page_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.LoginReputationClientRequest.page_url)
+}
+
+// optional .safe_browsing.LoginReputationClientRequest.TriggerType trigger_type = 2;
+inline bool LoginReputationClientRequest::_internal_has_trigger_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool LoginReputationClientRequest::has_trigger_type() const {
+  return _internal_has_trigger_type();
+}
+inline void LoginReputationClientRequest::clear_trigger_type() {
+  _impl_.trigger_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::safe_browsing::LoginReputationClientRequest_TriggerType LoginReputationClientRequest::_internal_trigger_type() const {
+  return static_cast< ::safe_browsing::LoginReputationClientRequest_TriggerType >(_impl_.trigger_type_);
+}
+inline ::safe_browsing::LoginReputationClientRequest_TriggerType LoginReputationClientRequest::trigger_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.trigger_type)
+  return _internal_trigger_type();
+}
+inline void LoginReputationClientRequest::_internal_set_trigger_type(::safe_browsing::LoginReputationClientRequest_TriggerType value) {
+  assert(::safe_browsing::LoginReputationClientRequest_TriggerType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.trigger_type_ = value;
+}
+inline void LoginReputationClientRequest::set_trigger_type(::safe_browsing::LoginReputationClientRequest_TriggerType value) {
+  _internal_set_trigger_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.trigger_type)
+}
+
+// repeated .safe_browsing.LoginReputationClientRequest.Frame frames = 3;
+inline int LoginReputationClientRequest::_internal_frames_size() const {
+  return _impl_.frames_.size();
+}
+inline int LoginReputationClientRequest::frames_size() const {
+  return _internal_frames_size();
+}
+inline void LoginReputationClientRequest::clear_frames() {
+  _impl_.frames_.Clear();
+}
+inline ::safe_browsing::LoginReputationClientRequest_Frame* LoginReputationClientRequest::mutable_frames(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.frames)
+  return _impl_.frames_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::LoginReputationClientRequest_Frame >*
+LoginReputationClientRequest::mutable_frames() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.LoginReputationClientRequest.frames)
+  return &_impl_.frames_;
+}
+inline const ::safe_browsing::LoginReputationClientRequest_Frame& LoginReputationClientRequest::_internal_frames(int index) const {
+  return _impl_.frames_.Get(index);
+}
+inline const ::safe_browsing::LoginReputationClientRequest_Frame& LoginReputationClientRequest::frames(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.frames)
+  return _internal_frames(index);
+}
+inline ::safe_browsing::LoginReputationClientRequest_Frame* LoginReputationClientRequest::_internal_add_frames() {
+  return _impl_.frames_.Add();
+}
+inline ::safe_browsing::LoginReputationClientRequest_Frame* LoginReputationClientRequest::add_frames() {
+  ::safe_browsing::LoginReputationClientRequest_Frame* _add = _internal_add_frames();
+  // @@protoc_insertion_point(field_add:safe_browsing.LoginReputationClientRequest.frames)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::LoginReputationClientRequest_Frame >&
+LoginReputationClientRequest::frames() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.LoginReputationClientRequest.frames)
+  return _impl_.frames_;
+}
+
+// optional .safe_browsing.LoginReputationClientRequest.PasswordReuseEvent password_reuse_event = 4;
+inline bool LoginReputationClientRequest::_internal_has_password_reuse_event() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.password_reuse_event_ != nullptr);
+  return value;
+}
+inline bool LoginReputationClientRequest::has_password_reuse_event() const {
+  return _internal_has_password_reuse_event();
+}
+inline void LoginReputationClientRequest::clear_password_reuse_event() {
+  if (_impl_.password_reuse_event_ != nullptr) _impl_.password_reuse_event_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent& LoginReputationClientRequest::_internal_password_reuse_event() const {
+  const ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* p = _impl_.password_reuse_event_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent&>(
+      ::safe_browsing::_LoginReputationClientRequest_PasswordReuseEvent_default_instance_);
+}
+inline const ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent& LoginReputationClientRequest::password_reuse_event() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.password_reuse_event)
+  return _internal_password_reuse_event();
+}
+inline void LoginReputationClientRequest::unsafe_arena_set_allocated_password_reuse_event(
+    ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* password_reuse_event) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.password_reuse_event_);
+  }
+  _impl_.password_reuse_event_ = password_reuse_event;
+  if (password_reuse_event) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.LoginReputationClientRequest.password_reuse_event)
+}
+inline ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* LoginReputationClientRequest::release_password_reuse_event() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* temp = _impl_.password_reuse_event_;
+  _impl_.password_reuse_event_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* LoginReputationClientRequest::unsafe_arena_release_password_reuse_event() {
+  // @@protoc_insertion_point(field_release:safe_browsing.LoginReputationClientRequest.password_reuse_event)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* temp = _impl_.password_reuse_event_;
+  _impl_.password_reuse_event_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* LoginReputationClientRequest::_internal_mutable_password_reuse_event() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.password_reuse_event_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent>(GetArenaForAllocation());
+    _impl_.password_reuse_event_ = p;
+  }
+  return _impl_.password_reuse_event_;
+}
+inline ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* LoginReputationClientRequest::mutable_password_reuse_event() {
+  ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* _msg = _internal_mutable_password_reuse_event();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.password_reuse_event)
+  return _msg;
+}
+inline void LoginReputationClientRequest::set_allocated_password_reuse_event(::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* password_reuse_event) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.password_reuse_event_;
+  }
+  if (password_reuse_event) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(password_reuse_event);
+    if (message_arena != submessage_arena) {
+      password_reuse_event = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, password_reuse_event, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.password_reuse_event_ = password_reuse_event;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.LoginReputationClientRequest.password_reuse_event)
+}
+
+// optional int32 stored_verdict_cnt = 5;
+inline bool LoginReputationClientRequest::_internal_has_stored_verdict_cnt() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool LoginReputationClientRequest::has_stored_verdict_cnt() const {
+  return _internal_has_stored_verdict_cnt();
+}
+inline void LoginReputationClientRequest::clear_stored_verdict_cnt() {
+  _impl_.stored_verdict_cnt_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline int32_t LoginReputationClientRequest::_internal_stored_verdict_cnt() const {
+  return _impl_.stored_verdict_cnt_;
+}
+inline int32_t LoginReputationClientRequest::stored_verdict_cnt() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.stored_verdict_cnt)
+  return _internal_stored_verdict_cnt();
+}
+inline void LoginReputationClientRequest::_internal_set_stored_verdict_cnt(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.stored_verdict_cnt_ = value;
+}
+inline void LoginReputationClientRequest::set_stored_verdict_cnt(int32_t value) {
+  _internal_set_stored_verdict_cnt(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.stored_verdict_cnt)
+}
+
+// optional .safe_browsing.ChromeUserPopulation population = 6;
+inline bool LoginReputationClientRequest::_internal_has_population() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.population_ != nullptr);
+  return value;
+}
+inline bool LoginReputationClientRequest::has_population() const {
+  return _internal_has_population();
+}
+inline void LoginReputationClientRequest::clear_population() {
+  if (_impl_.population_ != nullptr) _impl_.population_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::safe_browsing::ChromeUserPopulation& LoginReputationClientRequest::_internal_population() const {
+  const ::safe_browsing::ChromeUserPopulation* p = _impl_.population_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ChromeUserPopulation&>(
+      ::safe_browsing::_ChromeUserPopulation_default_instance_);
+}
+inline const ::safe_browsing::ChromeUserPopulation& LoginReputationClientRequest::population() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.population)
+  return _internal_population();
+}
+inline void LoginReputationClientRequest::unsafe_arena_set_allocated_population(
+    ::safe_browsing::ChromeUserPopulation* population) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.population_);
+  }
+  _impl_.population_ = population;
+  if (population) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.LoginReputationClientRequest.population)
+}
+inline ::safe_browsing::ChromeUserPopulation* LoginReputationClientRequest::release_population() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ChromeUserPopulation* temp = _impl_.population_;
+  _impl_.population_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ChromeUserPopulation* LoginReputationClientRequest::unsafe_arena_release_population() {
+  // @@protoc_insertion_point(field_release:safe_browsing.LoginReputationClientRequest.population)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ChromeUserPopulation* temp = _impl_.population_;
+  _impl_.population_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ChromeUserPopulation* LoginReputationClientRequest::_internal_mutable_population() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.population_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ChromeUserPopulation>(GetArenaForAllocation());
+    _impl_.population_ = p;
+  }
+  return _impl_.population_;
+}
+inline ::safe_browsing::ChromeUserPopulation* LoginReputationClientRequest::mutable_population() {
+  ::safe_browsing::ChromeUserPopulation* _msg = _internal_mutable_population();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.population)
+  return _msg;
+}
+inline void LoginReputationClientRequest::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.population_;
+  }
+  if (population) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(population);
+    if (message_arena != submessage_arena) {
+      population = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, population, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.population_ = population;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.LoginReputationClientRequest.population)
+}
+
+// optional bool clicked_through_interstitial = 7;
+inline bool LoginReputationClientRequest::_internal_has_clicked_through_interstitial() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool LoginReputationClientRequest::has_clicked_through_interstitial() const {
+  return _internal_has_clicked_through_interstitial();
+}
+inline void LoginReputationClientRequest::clear_clicked_through_interstitial() {
+  _impl_.clicked_through_interstitial_ = false;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline bool LoginReputationClientRequest::_internal_clicked_through_interstitial() const {
+  return _impl_.clicked_through_interstitial_;
+}
+inline bool LoginReputationClientRequest::clicked_through_interstitial() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientRequest.clicked_through_interstitial)
+  return _internal_clicked_through_interstitial();
+}
+inline void LoginReputationClientRequest::_internal_set_clicked_through_interstitial(bool value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.clicked_through_interstitial_ = value;
+}
+inline void LoginReputationClientRequest::set_clicked_through_interstitial(bool value) {
+  _internal_set_clicked_through_interstitial(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.clicked_through_interstitial)
+}
+
+// -------------------------------------------------------------------
+
+// LoginReputationClientResponse
+
+// optional .safe_browsing.LoginReputationClientResponse.VerdictType verdict_type = 1;
+inline bool LoginReputationClientResponse::_internal_has_verdict_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool LoginReputationClientResponse::has_verdict_type() const {
+  return _internal_has_verdict_type();
+}
+inline void LoginReputationClientResponse::clear_verdict_type() {
+  _impl_.verdict_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::safe_browsing::LoginReputationClientResponse_VerdictType LoginReputationClientResponse::_internal_verdict_type() const {
+  return static_cast< ::safe_browsing::LoginReputationClientResponse_VerdictType >(_impl_.verdict_type_);
+}
+inline ::safe_browsing::LoginReputationClientResponse_VerdictType LoginReputationClientResponse::verdict_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientResponse.verdict_type)
+  return _internal_verdict_type();
+}
+inline void LoginReputationClientResponse::_internal_set_verdict_type(::safe_browsing::LoginReputationClientResponse_VerdictType value) {
+  assert(::safe_browsing::LoginReputationClientResponse_VerdictType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.verdict_type_ = value;
+}
+inline void LoginReputationClientResponse::set_verdict_type(::safe_browsing::LoginReputationClientResponse_VerdictType value) {
+  _internal_set_verdict_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientResponse.verdict_type)
+}
+
+// optional int64 cache_duration_sec = 2;
+inline bool LoginReputationClientResponse::_internal_has_cache_duration_sec() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool LoginReputationClientResponse::has_cache_duration_sec() const {
+  return _internal_has_cache_duration_sec();
+}
+inline void LoginReputationClientResponse::clear_cache_duration_sec() {
+  _impl_.cache_duration_sec_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int64_t LoginReputationClientResponse::_internal_cache_duration_sec() const {
+  return _impl_.cache_duration_sec_;
+}
+inline int64_t LoginReputationClientResponse::cache_duration_sec() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientResponse.cache_duration_sec)
+  return _internal_cache_duration_sec();
+}
+inline void LoginReputationClientResponse::_internal_set_cache_duration_sec(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.cache_duration_sec_ = value;
+}
+inline void LoginReputationClientResponse::set_cache_duration_sec(int64_t value) {
+  _internal_set_cache_duration_sec(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientResponse.cache_duration_sec)
+}
+
+// optional string cache_expression = 3;
+inline bool LoginReputationClientResponse::_internal_has_cache_expression() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LoginReputationClientResponse::has_cache_expression() const {
+  return _internal_has_cache_expression();
+}
+inline void LoginReputationClientResponse::clear_cache_expression() {
+  _impl_.cache_expression_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LoginReputationClientResponse::cache_expression() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientResponse.cache_expression)
+  return _internal_cache_expression();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LoginReputationClientResponse::set_cache_expression(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.cache_expression_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientResponse.cache_expression)
+}
+inline std::string* LoginReputationClientResponse::mutable_cache_expression() {
+  std::string* _s = _internal_mutable_cache_expression();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientResponse.cache_expression)
+  return _s;
+}
+inline const std::string& LoginReputationClientResponse::_internal_cache_expression() const {
+  return _impl_.cache_expression_.Get();
+}
+inline void LoginReputationClientResponse::_internal_set_cache_expression(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.cache_expression_.Set(value, GetArenaForAllocation());
+}
+inline std::string* LoginReputationClientResponse::_internal_mutable_cache_expression() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.cache_expression_.Mutable(GetArenaForAllocation());
+}
+inline std::string* LoginReputationClientResponse::release_cache_expression() {
+  // @@protoc_insertion_point(field_release:safe_browsing.LoginReputationClientResponse.cache_expression)
+  if (!_internal_has_cache_expression()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.cache_expression_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.cache_expression_.IsDefault()) {
+    _impl_.cache_expression_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void LoginReputationClientResponse::set_allocated_cache_expression(std::string* cache_expression) {
+  if (cache_expression != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.cache_expression_.SetAllocated(cache_expression, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.cache_expression_.IsDefault()) {
+    _impl_.cache_expression_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.LoginReputationClientResponse.cache_expression)
+}
+
+// optional bool DEPRECATED_cache_expression_exact_match = 4 [deprecated = true];
+inline bool LoginReputationClientResponse::_internal_has_deprecated_cache_expression_exact_match() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool LoginReputationClientResponse::has_deprecated_cache_expression_exact_match() const {
+  return _internal_has_deprecated_cache_expression_exact_match();
+}
+inline void LoginReputationClientResponse::clear_deprecated_cache_expression_exact_match() {
+  _impl_.deprecated_cache_expression_exact_match_ = false;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline bool LoginReputationClientResponse::_internal_deprecated_cache_expression_exact_match() const {
+  return _impl_.deprecated_cache_expression_exact_match_;
+}
+inline bool LoginReputationClientResponse::deprecated_cache_expression_exact_match() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientResponse.DEPRECATED_cache_expression_exact_match)
+  return _internal_deprecated_cache_expression_exact_match();
+}
+inline void LoginReputationClientResponse::_internal_set_deprecated_cache_expression_exact_match(bool value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.deprecated_cache_expression_exact_match_ = value;
+}
+inline void LoginReputationClientResponse::set_deprecated_cache_expression_exact_match(bool value) {
+  _internal_set_deprecated_cache_expression_exact_match(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientResponse.DEPRECATED_cache_expression_exact_match)
+}
+
+// optional bytes verdict_token = 5;
+inline bool LoginReputationClientResponse::_internal_has_verdict_token() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LoginReputationClientResponse::has_verdict_token() const {
+  return _internal_has_verdict_token();
+}
+inline void LoginReputationClientResponse::clear_verdict_token() {
+  _impl_.verdict_token_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& LoginReputationClientResponse::verdict_token() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.LoginReputationClientResponse.verdict_token)
+  return _internal_verdict_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LoginReputationClientResponse::set_verdict_token(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.verdict_token_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientResponse.verdict_token)
+}
+inline std::string* LoginReputationClientResponse::mutable_verdict_token() {
+  std::string* _s = _internal_mutable_verdict_token();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientResponse.verdict_token)
+  return _s;
+}
+inline const std::string& LoginReputationClientResponse::_internal_verdict_token() const {
+  return _impl_.verdict_token_.Get();
+}
+inline void LoginReputationClientResponse::_internal_set_verdict_token(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.verdict_token_.Set(value, GetArenaForAllocation());
+}
+inline std::string* LoginReputationClientResponse::_internal_mutable_verdict_token() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.verdict_token_.Mutable(GetArenaForAllocation());
+}
+inline std::string* LoginReputationClientResponse::release_verdict_token() {
+  // @@protoc_insertion_point(field_release:safe_browsing.LoginReputationClientResponse.verdict_token)
+  if (!_internal_has_verdict_token()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.verdict_token_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.verdict_token_.IsDefault()) {
+    _impl_.verdict_token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void LoginReputationClientResponse::set_allocated_verdict_token(std::string* verdict_token) {
+  if (verdict_token != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.verdict_token_.SetAllocated(verdict_token, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.verdict_token_.IsDefault()) {
+    _impl_.verdict_token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.LoginReputationClientResponse.verdict_token)
+}
+
+// -------------------------------------------------------------------
+
+// ClientMalwareResponse
+
+// required bool blacklist = 1;
+inline bool ClientMalwareResponse::_internal_has_blacklist() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientMalwareResponse::has_blacklist() const {
+  return _internal_has_blacklist();
+}
+inline void ClientMalwareResponse::clear_blacklist() {
+  _impl_.blacklist_ = false;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline bool ClientMalwareResponse::_internal_blacklist() const {
+  return _impl_.blacklist_;
+}
+inline bool ClientMalwareResponse::blacklist() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareResponse.blacklist)
+  return _internal_blacklist();
+}
+inline void ClientMalwareResponse::_internal_set_blacklist(bool value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.blacklist_ = value;
+}
+inline void ClientMalwareResponse::set_blacklist(bool value) {
+  _internal_set_blacklist(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareResponse.blacklist)
+}
+
+// optional string bad_ip = 2;
+inline bool ClientMalwareResponse::_internal_has_bad_ip() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientMalwareResponse::has_bad_ip() const {
+  return _internal_has_bad_ip();
+}
+inline void ClientMalwareResponse::clear_bad_ip() {
+  _impl_.bad_ip_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientMalwareResponse::bad_ip() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareResponse.bad_ip)
+  return _internal_bad_ip();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientMalwareResponse::set_bad_ip(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.bad_ip_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareResponse.bad_ip)
+}
+inline std::string* ClientMalwareResponse::mutable_bad_ip() {
+  std::string* _s = _internal_mutable_bad_ip();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareResponse.bad_ip)
+  return _s;
+}
+inline const std::string& ClientMalwareResponse::_internal_bad_ip() const {
+  return _impl_.bad_ip_.Get();
+}
+inline void ClientMalwareResponse::_internal_set_bad_ip(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.bad_ip_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientMalwareResponse::_internal_mutable_bad_ip() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.bad_ip_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientMalwareResponse::release_bad_ip() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareResponse.bad_ip)
+  if (!_internal_has_bad_ip()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.bad_ip_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.bad_ip_.IsDefault()) {
+    _impl_.bad_ip_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientMalwareResponse::set_allocated_bad_ip(std::string* bad_ip) {
+  if (bad_ip != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.bad_ip_.SetAllocated(bad_ip, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.bad_ip_.IsDefault()) {
+    _impl_.bad_ip_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareResponse.bad_ip)
+}
+
+// optional string bad_url = 3;
+inline bool ClientMalwareResponse::_internal_has_bad_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientMalwareResponse::has_bad_url() const {
+  return _internal_has_bad_url();
+}
+inline void ClientMalwareResponse::clear_bad_url() {
+  _impl_.bad_url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientMalwareResponse::bad_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareResponse.bad_url)
+  return _internal_bad_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientMalwareResponse::set_bad_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.bad_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareResponse.bad_url)
+}
+inline std::string* ClientMalwareResponse::mutable_bad_url() {
+  std::string* _s = _internal_mutable_bad_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareResponse.bad_url)
+  return _s;
+}
+inline const std::string& ClientMalwareResponse::_internal_bad_url() const {
+  return _impl_.bad_url_.Get();
+}
+inline void ClientMalwareResponse::_internal_set_bad_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.bad_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientMalwareResponse::_internal_mutable_bad_url() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.bad_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientMalwareResponse::release_bad_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareResponse.bad_url)
+  if (!_internal_has_bad_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.bad_url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.bad_url_.IsDefault()) {
+    _impl_.bad_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientMalwareResponse::set_allocated_bad_url(std::string* bad_url) {
+  if (bad_url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.bad_url_.SetAllocated(bad_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.bad_url_.IsDefault()) {
+    _impl_.bad_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareResponse.bad_url)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_Digests
+
+// optional bytes sha256 = 1;
+inline bool ClientDownloadRequest_Digests::_internal_has_sha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_Digests::has_sha256() const {
+  return _internal_has_sha256();
+}
+inline void ClientDownloadRequest_Digests::clear_sha256() {
+  _impl_.sha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadRequest_Digests::sha256() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Digests.sha256)
+  return _internal_sha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_Digests::set_sha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.sha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Digests.sha256)
+}
+inline std::string* ClientDownloadRequest_Digests::mutable_sha256() {
+  std::string* _s = _internal_mutable_sha256();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Digests.sha256)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_Digests::_internal_sha256() const {
+  return _impl_.sha256_.Get();
+}
+inline void ClientDownloadRequest_Digests::_internal_set_sha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.sha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_Digests::_internal_mutable_sha256() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.sha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_Digests::release_sha256() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.Digests.sha256)
+  if (!_internal_has_sha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.sha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sha256_.IsDefault()) {
+    _impl_.sha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_Digests::set_allocated_sha256(std::string* sha256) {
+  if (sha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.sha256_.SetAllocated(sha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sha256_.IsDefault()) {
+    _impl_.sha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.Digests.sha256)
+}
+
+// optional bytes sha1 = 2;
+inline bool ClientDownloadRequest_Digests::_internal_has_sha1() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_Digests::has_sha1() const {
+  return _internal_has_sha1();
+}
+inline void ClientDownloadRequest_Digests::clear_sha1() {
+  _impl_.sha1_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientDownloadRequest_Digests::sha1() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Digests.sha1)
+  return _internal_sha1();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_Digests::set_sha1(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.sha1_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Digests.sha1)
+}
+inline std::string* ClientDownloadRequest_Digests::mutable_sha1() {
+  std::string* _s = _internal_mutable_sha1();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Digests.sha1)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_Digests::_internal_sha1() const {
+  return _impl_.sha1_.Get();
+}
+inline void ClientDownloadRequest_Digests::_internal_set_sha1(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.sha1_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_Digests::_internal_mutable_sha1() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.sha1_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_Digests::release_sha1() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.Digests.sha1)
+  if (!_internal_has_sha1()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.sha1_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sha1_.IsDefault()) {
+    _impl_.sha1_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_Digests::set_allocated_sha1(std::string* sha1) {
+  if (sha1 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.sha1_.SetAllocated(sha1, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.sha1_.IsDefault()) {
+    _impl_.sha1_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.Digests.sha1)
+}
+
+// optional bytes md5 = 3;
+inline bool ClientDownloadRequest_Digests::_internal_has_md5() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_Digests::has_md5() const {
+  return _internal_has_md5();
+}
+inline void ClientDownloadRequest_Digests::clear_md5() {
+  _impl_.md5_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientDownloadRequest_Digests::md5() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Digests.md5)
+  return _internal_md5();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_Digests::set_md5(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.md5_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Digests.md5)
+}
+inline std::string* ClientDownloadRequest_Digests::mutable_md5() {
+  std::string* _s = _internal_mutable_md5();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Digests.md5)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_Digests::_internal_md5() const {
+  return _impl_.md5_.Get();
+}
+inline void ClientDownloadRequest_Digests::_internal_set_md5(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.md5_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_Digests::_internal_mutable_md5() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.md5_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_Digests::release_md5() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.Digests.md5)
+  if (!_internal_has_md5()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.md5_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.md5_.IsDefault()) {
+    _impl_.md5_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_Digests::set_allocated_md5(std::string* md5) {
+  if (md5 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.md5_.SetAllocated(md5, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.md5_.IsDefault()) {
+    _impl_.md5_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.Digests.md5)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_Resource
+
+// required string url = 1;
+inline bool ClientDownloadRequest_Resource::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_Resource::has_url() const {
+  return _internal_has_url();
+}
+inline void ClientDownloadRequest_Resource::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadRequest_Resource::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Resource.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_Resource::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Resource.url)
+}
+inline std::string* ClientDownloadRequest_Resource::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Resource.url)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_Resource::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void ClientDownloadRequest_Resource::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_Resource::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_Resource::release_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.Resource.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_Resource::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.Resource.url)
+}
+
+// required .safe_browsing.ClientDownloadRequest.ResourceType type = 2;
+inline bool ClientDownloadRequest_Resource::_internal_has_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_Resource::has_type() const {
+  return _internal_has_type();
+}
+inline void ClientDownloadRequest_Resource::clear_type() {
+  _impl_.type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::safe_browsing::ClientDownloadRequest_ResourceType ClientDownloadRequest_Resource::_internal_type() const {
+  return static_cast< ::safe_browsing::ClientDownloadRequest_ResourceType >(_impl_.type_);
+}
+inline ::safe_browsing::ClientDownloadRequest_ResourceType ClientDownloadRequest_Resource::type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Resource.type)
+  return _internal_type();
+}
+inline void ClientDownloadRequest_Resource::_internal_set_type(::safe_browsing::ClientDownloadRequest_ResourceType value) {
+  assert(::safe_browsing::ClientDownloadRequest_ResourceType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.type_ = value;
+}
+inline void ClientDownloadRequest_Resource::set_type(::safe_browsing::ClientDownloadRequest_ResourceType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Resource.type)
+}
+
+// optional bytes remote_ip = 3;
+inline bool ClientDownloadRequest_Resource::_internal_has_remote_ip() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_Resource::has_remote_ip() const {
+  return _internal_has_remote_ip();
+}
+inline void ClientDownloadRequest_Resource::clear_remote_ip() {
+  _impl_.remote_ip_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientDownloadRequest_Resource::remote_ip() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Resource.remote_ip)
+  return _internal_remote_ip();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_Resource::set_remote_ip(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.remote_ip_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Resource.remote_ip)
+}
+inline std::string* ClientDownloadRequest_Resource::mutable_remote_ip() {
+  std::string* _s = _internal_mutable_remote_ip();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Resource.remote_ip)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_Resource::_internal_remote_ip() const {
+  return _impl_.remote_ip_.Get();
+}
+inline void ClientDownloadRequest_Resource::_internal_set_remote_ip(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.remote_ip_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_Resource::_internal_mutable_remote_ip() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.remote_ip_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_Resource::release_remote_ip() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.Resource.remote_ip)
+  if (!_internal_has_remote_ip()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.remote_ip_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.remote_ip_.IsDefault()) {
+    _impl_.remote_ip_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_Resource::set_allocated_remote_ip(std::string* remote_ip) {
+  if (remote_ip != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.remote_ip_.SetAllocated(remote_ip, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.remote_ip_.IsDefault()) {
+    _impl_.remote_ip_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.Resource.remote_ip)
+}
+
+// optional string referrer = 4;
+inline bool ClientDownloadRequest_Resource::_internal_has_referrer() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_Resource::has_referrer() const {
+  return _internal_has_referrer();
+}
+inline void ClientDownloadRequest_Resource::clear_referrer() {
+  _impl_.referrer_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientDownloadRequest_Resource::referrer() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Resource.referrer)
+  return _internal_referrer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_Resource::set_referrer(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.referrer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Resource.referrer)
+}
+inline std::string* ClientDownloadRequest_Resource::mutable_referrer() {
+  std::string* _s = _internal_mutable_referrer();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Resource.referrer)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_Resource::_internal_referrer() const {
+  return _impl_.referrer_.Get();
+}
+inline void ClientDownloadRequest_Resource::_internal_set_referrer(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.referrer_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_Resource::_internal_mutable_referrer() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.referrer_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_Resource::release_referrer() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.Resource.referrer)
+  if (!_internal_has_referrer()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.referrer_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_.IsDefault()) {
+    _impl_.referrer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_Resource::set_allocated_referrer(std::string* referrer) {
+  if (referrer != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.referrer_.SetAllocated(referrer, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_.IsDefault()) {
+    _impl_.referrer_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.Resource.referrer)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_CertificateChain_Element
+
+// optional bytes certificate = 1;
+inline bool ClientDownloadRequest_CertificateChain_Element::_internal_has_certificate() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_CertificateChain_Element::has_certificate() const {
+  return _internal_has_certificate();
+}
+inline void ClientDownloadRequest_CertificateChain_Element::clear_certificate() {
+  _impl_.certificate_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadRequest_CertificateChain_Element::certificate() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate)
+  return _internal_certificate();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_CertificateChain_Element::set_certificate(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.certificate_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate)
+}
+inline std::string* ClientDownloadRequest_CertificateChain_Element::mutable_certificate() {
+  std::string* _s = _internal_mutable_certificate();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_CertificateChain_Element::_internal_certificate() const {
+  return _impl_.certificate_.Get();
+}
+inline void ClientDownloadRequest_CertificateChain_Element::_internal_set_certificate(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.certificate_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_CertificateChain_Element::_internal_mutable_certificate() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.certificate_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_CertificateChain_Element::release_certificate() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate)
+  if (!_internal_has_certificate()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.certificate_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.certificate_.IsDefault()) {
+    _impl_.certificate_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_CertificateChain_Element::set_allocated_certificate(std::string* certificate) {
+  if (certificate != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.certificate_.SetAllocated(certificate, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.certificate_.IsDefault()) {
+    _impl_.certificate_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_CertificateChain
+
+// repeated .safe_browsing.ClientDownloadRequest.CertificateChain.Element element = 1;
+inline int ClientDownloadRequest_CertificateChain::_internal_element_size() const {
+  return _impl_.element_.size();
+}
+inline int ClientDownloadRequest_CertificateChain::element_size() const {
+  return _internal_element_size();
+}
+inline void ClientDownloadRequest_CertificateChain::clear_element() {
+  _impl_.element_.Clear();
+}
+inline ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* ClientDownloadRequest_CertificateChain::mutable_element(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.CertificateChain.element)
+  return _impl_.element_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >*
+ClientDownloadRequest_CertificateChain::mutable_element() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.CertificateChain.element)
+  return &_impl_.element_;
+}
+inline const ::safe_browsing::ClientDownloadRequest_CertificateChain_Element& ClientDownloadRequest_CertificateChain::_internal_element(int index) const {
+  return _impl_.element_.Get(index);
+}
+inline const ::safe_browsing::ClientDownloadRequest_CertificateChain_Element& ClientDownloadRequest_CertificateChain::element(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.CertificateChain.element)
+  return _internal_element(index);
+}
+inline ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* ClientDownloadRequest_CertificateChain::_internal_add_element() {
+  return _impl_.element_.Add();
+}
+inline ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* ClientDownloadRequest_CertificateChain::add_element() {
+  ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* _add = _internal_add_element();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.CertificateChain.element)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >&
+ClientDownloadRequest_CertificateChain::element() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.CertificateChain.element)
+  return _impl_.element_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_ExtendedAttr
+
+// required string key = 1;
+inline bool ClientDownloadRequest_ExtendedAttr::_internal_has_key() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_ExtendedAttr::has_key() const {
+  return _internal_has_key();
+}
+inline void ClientDownloadRequest_ExtendedAttr::clear_key() {
+  _impl_.key_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadRequest_ExtendedAttr::key() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ExtendedAttr.key)
+  return _internal_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_ExtendedAttr::set_key(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.ExtendedAttr.key)
+}
+inline std::string* ClientDownloadRequest_ExtendedAttr::mutable_key() {
+  std::string* _s = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ExtendedAttr.key)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_ExtendedAttr::_internal_key() const {
+  return _impl_.key_.Get();
+}
+inline void ClientDownloadRequest_ExtendedAttr::_internal_set_key(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.key_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_ExtendedAttr::_internal_mutable_key() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.key_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_ExtendedAttr::release_key() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.ExtendedAttr.key)
+  if (!_internal_has_key()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.key_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.key_.IsDefault()) {
+    _impl_.key_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_ExtendedAttr::set_allocated_key(std::string* key) {
+  if (key != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.key_.IsDefault()) {
+    _impl_.key_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.ExtendedAttr.key)
+}
+
+// optional bytes value = 2;
+inline bool ClientDownloadRequest_ExtendedAttr::_internal_has_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_ExtendedAttr::has_value() const {
+  return _internal_has_value();
+}
+inline void ClientDownloadRequest_ExtendedAttr::clear_value() {
+  _impl_.value_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientDownloadRequest_ExtendedAttr::value() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ExtendedAttr.value)
+  return _internal_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_ExtendedAttr::set_value(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.ExtendedAttr.value)
+}
+inline std::string* ClientDownloadRequest_ExtendedAttr::mutable_value() {
+  std::string* _s = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ExtendedAttr.value)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_ExtendedAttr::_internal_value() const {
+  return _impl_.value_.Get();
+}
+inline void ClientDownloadRequest_ExtendedAttr::_internal_set_value(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_ExtendedAttr::_internal_mutable_value() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_ExtendedAttr::release_value() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.ExtendedAttr.value)
+  if (!_internal_has_value()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.value_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.value_.IsDefault()) {
+    _impl_.value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_ExtendedAttr::set_allocated_value(std::string* value) {
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.value_.IsDefault()) {
+    _impl_.value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.ExtendedAttr.value)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_SignatureInfo
+
+// repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1;
+inline int ClientDownloadRequest_SignatureInfo::_internal_certificate_chain_size() const {
+  return _impl_.certificate_chain_.size();
+}
+inline int ClientDownloadRequest_SignatureInfo::certificate_chain_size() const {
+  return _internal_certificate_chain_size();
+}
+inline void ClientDownloadRequest_SignatureInfo::clear_certificate_chain() {
+  _impl_.certificate_chain_.Clear();
+}
+inline ::safe_browsing::ClientDownloadRequest_CertificateChain* ClientDownloadRequest_SignatureInfo::mutable_certificate_chain(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.SignatureInfo.certificate_chain)
+  return _impl_.certificate_chain_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain >*
+ClientDownloadRequest_SignatureInfo::mutable_certificate_chain() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.SignatureInfo.certificate_chain)
+  return &_impl_.certificate_chain_;
+}
+inline const ::safe_browsing::ClientDownloadRequest_CertificateChain& ClientDownloadRequest_SignatureInfo::_internal_certificate_chain(int index) const {
+  return _impl_.certificate_chain_.Get(index);
+}
+inline const ::safe_browsing::ClientDownloadRequest_CertificateChain& ClientDownloadRequest_SignatureInfo::certificate_chain(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.SignatureInfo.certificate_chain)
+  return _internal_certificate_chain(index);
+}
+inline ::safe_browsing::ClientDownloadRequest_CertificateChain* ClientDownloadRequest_SignatureInfo::_internal_add_certificate_chain() {
+  return _impl_.certificate_chain_.Add();
+}
+inline ::safe_browsing::ClientDownloadRequest_CertificateChain* ClientDownloadRequest_SignatureInfo::add_certificate_chain() {
+  ::safe_browsing::ClientDownloadRequest_CertificateChain* _add = _internal_add_certificate_chain();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.SignatureInfo.certificate_chain)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain >&
+ClientDownloadRequest_SignatureInfo::certificate_chain() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.SignatureInfo.certificate_chain)
+  return _impl_.certificate_chain_;
+}
+
+// optional bool trusted = 2;
+inline bool ClientDownloadRequest_SignatureInfo::_internal_has_trusted() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_SignatureInfo::has_trusted() const {
+  return _internal_has_trusted();
+}
+inline void ClientDownloadRequest_SignatureInfo::clear_trusted() {
+  _impl_.trusted_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool ClientDownloadRequest_SignatureInfo::_internal_trusted() const {
+  return _impl_.trusted_;
+}
+inline bool ClientDownloadRequest_SignatureInfo::trusted() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.SignatureInfo.trusted)
+  return _internal_trusted();
+}
+inline void ClientDownloadRequest_SignatureInfo::_internal_set_trusted(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.trusted_ = value;
+}
+inline void ClientDownloadRequest_SignatureInfo::set_trusted(bool value) {
+  _internal_set_trusted(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.SignatureInfo.trusted)
+}
+
+// repeated bytes signed_data = 3;
+inline int ClientDownloadRequest_SignatureInfo::_internal_signed_data_size() const {
+  return _impl_.signed_data_.size();
+}
+inline int ClientDownloadRequest_SignatureInfo::signed_data_size() const {
+  return _internal_signed_data_size();
+}
+inline void ClientDownloadRequest_SignatureInfo::clear_signed_data() {
+  _impl_.signed_data_.Clear();
+}
+inline std::string* ClientDownloadRequest_SignatureInfo::add_signed_data() {
+  std::string* _s = _internal_add_signed_data();
+  // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_SignatureInfo::_internal_signed_data(int index) const {
+  return _impl_.signed_data_.Get(index);
+}
+inline const std::string& ClientDownloadRequest_SignatureInfo::signed_data(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+  return _internal_signed_data(index);
+}
+inline std::string* ClientDownloadRequest_SignatureInfo::mutable_signed_data(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+  return _impl_.signed_data_.Mutable(index);
+}
+inline void ClientDownloadRequest_SignatureInfo::set_signed_data(int index, const std::string& value) {
+  _impl_.signed_data_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+}
+inline void ClientDownloadRequest_SignatureInfo::set_signed_data(int index, std::string&& value) {
+  _impl_.signed_data_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+}
+inline void ClientDownloadRequest_SignatureInfo::set_signed_data(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.signed_data_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+}
+inline void ClientDownloadRequest_SignatureInfo::set_signed_data(int index, const void* value, size_t size) {
+  _impl_.signed_data_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+}
+inline std::string* ClientDownloadRequest_SignatureInfo::_internal_add_signed_data() {
+  return _impl_.signed_data_.Add();
+}
+inline void ClientDownloadRequest_SignatureInfo::add_signed_data(const std::string& value) {
+  _impl_.signed_data_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+}
+inline void ClientDownloadRequest_SignatureInfo::add_signed_data(std::string&& value) {
+  _impl_.signed_data_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+}
+inline void ClientDownloadRequest_SignatureInfo::add_signed_data(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.signed_data_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+}
+inline void ClientDownloadRequest_SignatureInfo::add_signed_data(const void* value, size_t size) {
+  _impl_.signed_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ClientDownloadRequest_SignatureInfo::signed_data() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+  return _impl_.signed_data_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ClientDownloadRequest_SignatureInfo::mutable_signed_data() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+  return &_impl_.signed_data_;
+}
+
+// repeated .safe_browsing.ClientDownloadRequest.ExtendedAttr xattr = 4;
+inline int ClientDownloadRequest_SignatureInfo::_internal_xattr_size() const {
+  return _impl_.xattr_.size();
+}
+inline int ClientDownloadRequest_SignatureInfo::xattr_size() const {
+  return _internal_xattr_size();
+}
+inline void ClientDownloadRequest_SignatureInfo::clear_xattr() {
+  _impl_.xattr_.Clear();
+}
+inline ::safe_browsing::ClientDownloadRequest_ExtendedAttr* ClientDownloadRequest_SignatureInfo::mutable_xattr(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.SignatureInfo.xattr)
+  return _impl_.xattr_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ExtendedAttr >*
+ClientDownloadRequest_SignatureInfo::mutable_xattr() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.SignatureInfo.xattr)
+  return &_impl_.xattr_;
+}
+inline const ::safe_browsing::ClientDownloadRequest_ExtendedAttr& ClientDownloadRequest_SignatureInfo::_internal_xattr(int index) const {
+  return _impl_.xattr_.Get(index);
+}
+inline const ::safe_browsing::ClientDownloadRequest_ExtendedAttr& ClientDownloadRequest_SignatureInfo::xattr(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.SignatureInfo.xattr)
+  return _internal_xattr(index);
+}
+inline ::safe_browsing::ClientDownloadRequest_ExtendedAttr* ClientDownloadRequest_SignatureInfo::_internal_add_xattr() {
+  return _impl_.xattr_.Add();
+}
+inline ::safe_browsing::ClientDownloadRequest_ExtendedAttr* ClientDownloadRequest_SignatureInfo::add_xattr() {
+  ::safe_browsing::ClientDownloadRequest_ExtendedAttr* _add = _internal_add_xattr();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.SignatureInfo.xattr)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ExtendedAttr >&
+ClientDownloadRequest_SignatureInfo::xattr() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.SignatureInfo.xattr)
+  return _impl_.xattr_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_PEImageHeaders_DebugData
+
+// optional bytes directory_entry = 1;
+inline bool ClientDownloadRequest_PEImageHeaders_DebugData::_internal_has_directory_entry() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_PEImageHeaders_DebugData::has_directory_entry() const {
+  return _internal_has_directory_entry();
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::clear_directory_entry() {
+  _impl_.directory_entry_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders_DebugData::directory_entry() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry)
+  return _internal_directory_entry();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_PEImageHeaders_DebugData::set_directory_entry(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.directory_entry_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry)
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders_DebugData::mutable_directory_entry() {
+  std::string* _s = _internal_mutable_directory_entry();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders_DebugData::_internal_directory_entry() const {
+  return _impl_.directory_entry_.Get();
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::_internal_set_directory_entry(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.directory_entry_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders_DebugData::_internal_mutable_directory_entry() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.directory_entry_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders_DebugData::release_directory_entry() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry)
+  if (!_internal_has_directory_entry()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.directory_entry_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directory_entry_.IsDefault()) {
+    _impl_.directory_entry_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_allocated_directory_entry(std::string* directory_entry) {
+  if (directory_entry != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.directory_entry_.SetAllocated(directory_entry, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.directory_entry_.IsDefault()) {
+    _impl_.directory_entry_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry)
+}
+
+// optional bytes raw_data = 2;
+inline bool ClientDownloadRequest_PEImageHeaders_DebugData::_internal_has_raw_data() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_PEImageHeaders_DebugData::has_raw_data() const {
+  return _internal_has_raw_data();
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::clear_raw_data() {
+  _impl_.raw_data_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders_DebugData::raw_data() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data)
+  return _internal_raw_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_PEImageHeaders_DebugData::set_raw_data(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.raw_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data)
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders_DebugData::mutable_raw_data() {
+  std::string* _s = _internal_mutable_raw_data();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders_DebugData::_internal_raw_data() const {
+  return _impl_.raw_data_.Get();
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::_internal_set_raw_data(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.raw_data_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders_DebugData::_internal_mutable_raw_data() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.raw_data_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders_DebugData::release_raw_data() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data)
+  if (!_internal_has_raw_data()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.raw_data_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.raw_data_.IsDefault()) {
+    _impl_.raw_data_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_allocated_raw_data(std::string* raw_data) {
+  if (raw_data != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.raw_data_.SetAllocated(raw_data, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.raw_data_.IsDefault()) {
+    _impl_.raw_data_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_PEImageHeaders
+
+// optional bytes dos_header = 1;
+inline bool ClientDownloadRequest_PEImageHeaders::_internal_has_dos_header() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_PEImageHeaders::has_dos_header() const {
+  return _internal_has_dos_header();
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_dos_header() {
+  _impl_.dos_header_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders::dos_header() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header)
+  return _internal_dos_header();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_PEImageHeaders::set_dos_header(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.dos_header_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header)
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::mutable_dos_header() {
+  std::string* _s = _internal_mutable_dos_header();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders::_internal_dos_header() const {
+  return _impl_.dos_header_.Get();
+}
+inline void ClientDownloadRequest_PEImageHeaders::_internal_set_dos_header(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.dos_header_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::_internal_mutable_dos_header() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.dos_header_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::release_dos_header() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header)
+  if (!_internal_has_dos_header()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.dos_header_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.dos_header_.IsDefault()) {
+    _impl_.dos_header_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_allocated_dos_header(std::string* dos_header) {
+  if (dos_header != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.dos_header_.SetAllocated(dos_header, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.dos_header_.IsDefault()) {
+    _impl_.dos_header_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header)
+}
+
+// optional bytes file_header = 2;
+inline bool ClientDownloadRequest_PEImageHeaders::_internal_has_file_header() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_PEImageHeaders::has_file_header() const {
+  return _internal_has_file_header();
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_file_header() {
+  _impl_.file_header_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders::file_header() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header)
+  return _internal_file_header();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_PEImageHeaders::set_file_header(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.file_header_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header)
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::mutable_file_header() {
+  std::string* _s = _internal_mutable_file_header();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders::_internal_file_header() const {
+  return _impl_.file_header_.Get();
+}
+inline void ClientDownloadRequest_PEImageHeaders::_internal_set_file_header(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.file_header_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::_internal_mutable_file_header() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.file_header_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::release_file_header() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header)
+  if (!_internal_has_file_header()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.file_header_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.file_header_.IsDefault()) {
+    _impl_.file_header_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_allocated_file_header(std::string* file_header) {
+  if (file_header != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.file_header_.SetAllocated(file_header, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.file_header_.IsDefault()) {
+    _impl_.file_header_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header)
+}
+
+// optional bytes optional_headers32 = 3;
+inline bool ClientDownloadRequest_PEImageHeaders::_internal_has_optional_headers32() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_PEImageHeaders::has_optional_headers32() const {
+  return _internal_has_optional_headers32();
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_optional_headers32() {
+  _impl_.optional_headers32_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders::optional_headers32() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32)
+  return _internal_optional_headers32();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_PEImageHeaders::set_optional_headers32(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.optional_headers32_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32)
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::mutable_optional_headers32() {
+  std::string* _s = _internal_mutable_optional_headers32();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders::_internal_optional_headers32() const {
+  return _impl_.optional_headers32_.Get();
+}
+inline void ClientDownloadRequest_PEImageHeaders::_internal_set_optional_headers32(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.optional_headers32_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::_internal_mutable_optional_headers32() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.optional_headers32_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::release_optional_headers32() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32)
+  if (!_internal_has_optional_headers32()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.optional_headers32_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.optional_headers32_.IsDefault()) {
+    _impl_.optional_headers32_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_allocated_optional_headers32(std::string* optional_headers32) {
+  if (optional_headers32 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.optional_headers32_.SetAllocated(optional_headers32, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.optional_headers32_.IsDefault()) {
+    _impl_.optional_headers32_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32)
+}
+
+// optional bytes optional_headers64 = 4;
+inline bool ClientDownloadRequest_PEImageHeaders::_internal_has_optional_headers64() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_PEImageHeaders::has_optional_headers64() const {
+  return _internal_has_optional_headers64();
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_optional_headers64() {
+  _impl_.optional_headers64_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders::optional_headers64() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64)
+  return _internal_optional_headers64();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_PEImageHeaders::set_optional_headers64(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.optional_headers64_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64)
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::mutable_optional_headers64() {
+  std::string* _s = _internal_mutable_optional_headers64();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders::_internal_optional_headers64() const {
+  return _impl_.optional_headers64_.Get();
+}
+inline void ClientDownloadRequest_PEImageHeaders::_internal_set_optional_headers64(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.optional_headers64_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::_internal_mutable_optional_headers64() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.optional_headers64_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::release_optional_headers64() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64)
+  if (!_internal_has_optional_headers64()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.optional_headers64_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.optional_headers64_.IsDefault()) {
+    _impl_.optional_headers64_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_allocated_optional_headers64(std::string* optional_headers64) {
+  if (optional_headers64 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.optional_headers64_.SetAllocated(optional_headers64, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.optional_headers64_.IsDefault()) {
+    _impl_.optional_headers64_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64)
+}
+
+// repeated bytes section_header = 5;
+inline int ClientDownloadRequest_PEImageHeaders::_internal_section_header_size() const {
+  return _impl_.section_header_.size();
+}
+inline int ClientDownloadRequest_PEImageHeaders::section_header_size() const {
+  return _internal_section_header_size();
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_section_header() {
+  _impl_.section_header_.Clear();
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::add_section_header() {
+  std::string* _s = _internal_add_section_header();
+  // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders::_internal_section_header(int index) const {
+  return _impl_.section_header_.Get(index);
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders::section_header(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+  return _internal_section_header(index);
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::mutable_section_header(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+  return _impl_.section_header_.Mutable(index);
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_section_header(int index, const std::string& value) {
+  _impl_.section_header_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_section_header(int index, std::string&& value) {
+  _impl_.section_header_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_section_header(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.section_header_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_section_header(int index, const void* value, size_t size) {
+  _impl_.section_header_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::_internal_add_section_header() {
+  return _impl_.section_header_.Add();
+}
+inline void ClientDownloadRequest_PEImageHeaders::add_section_header(const std::string& value) {
+  _impl_.section_header_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+}
+inline void ClientDownloadRequest_PEImageHeaders::add_section_header(std::string&& value) {
+  _impl_.section_header_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+}
+inline void ClientDownloadRequest_PEImageHeaders::add_section_header(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.section_header_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+}
+inline void ClientDownloadRequest_PEImageHeaders::add_section_header(const void* value, size_t size) {
+  _impl_.section_header_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ClientDownloadRequest_PEImageHeaders::section_header() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+  return _impl_.section_header_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ClientDownloadRequest_PEImageHeaders::mutable_section_header() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+  return &_impl_.section_header_;
+}
+
+// optional bytes export_section_data = 6;
+inline bool ClientDownloadRequest_PEImageHeaders::_internal_has_export_section_data() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_PEImageHeaders::has_export_section_data() const {
+  return _internal_has_export_section_data();
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_export_section_data() {
+  _impl_.export_section_data_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders::export_section_data() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data)
+  return _internal_export_section_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_PEImageHeaders::set_export_section_data(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.export_section_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data)
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::mutable_export_section_data() {
+  std::string* _s = _internal_mutable_export_section_data();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_PEImageHeaders::_internal_export_section_data() const {
+  return _impl_.export_section_data_.Get();
+}
+inline void ClientDownloadRequest_PEImageHeaders::_internal_set_export_section_data(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.export_section_data_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::_internal_mutable_export_section_data() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.export_section_data_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_PEImageHeaders::release_export_section_data() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data)
+  if (!_internal_has_export_section_data()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.export_section_data_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.export_section_data_.IsDefault()) {
+    _impl_.export_section_data_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_allocated_export_section_data(std::string* export_section_data) {
+  if (export_section_data != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.export_section_data_.SetAllocated(export_section_data, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.export_section_data_.IsDefault()) {
+    _impl_.export_section_data_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data)
+}
+
+// repeated .safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData debug_data = 7;
+inline int ClientDownloadRequest_PEImageHeaders::_internal_debug_data_size() const {
+  return _impl_.debug_data_.size();
+}
+inline int ClientDownloadRequest_PEImageHeaders::debug_data_size() const {
+  return _internal_debug_data_size();
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_debug_data() {
+  _impl_.debug_data_.Clear();
+}
+inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData* ClientDownloadRequest_PEImageHeaders::mutable_debug_data(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.debug_data)
+  return _impl_.debug_data_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData >*
+ClientDownloadRequest_PEImageHeaders::mutable_debug_data() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.PEImageHeaders.debug_data)
+  return &_impl_.debug_data_;
+}
+inline const ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData& ClientDownloadRequest_PEImageHeaders::_internal_debug_data(int index) const {
+  return _impl_.debug_data_.Get(index);
+}
+inline const ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData& ClientDownloadRequest_PEImageHeaders::debug_data(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.debug_data)
+  return _internal_debug_data(index);
+}
+inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData* ClientDownloadRequest_PEImageHeaders::_internal_add_debug_data() {
+  return _impl_.debug_data_.Add();
+}
+inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData* ClientDownloadRequest_PEImageHeaders::add_debug_data() {
+  ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData* _add = _internal_add_debug_data();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.PEImageHeaders.debug_data)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData >&
+ClientDownloadRequest_PEImageHeaders::debug_data() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.PEImageHeaders.debug_data)
+  return _impl_.debug_data_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_MachOHeaders_LoadCommand
+
+// required uint32 command_id = 1;
+inline bool ClientDownloadRequest_MachOHeaders_LoadCommand::_internal_has_command_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_MachOHeaders_LoadCommand::has_command_id() const {
+  return _internal_has_command_id();
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::clear_command_id() {
+  _impl_.command_id_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t ClientDownloadRequest_MachOHeaders_LoadCommand::_internal_command_id() const {
+  return _impl_.command_id_;
+}
+inline uint32_t ClientDownloadRequest_MachOHeaders_LoadCommand::command_id() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command_id)
+  return _internal_command_id();
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::_internal_set_command_id(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.command_id_ = value;
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_command_id(uint32_t value) {
+  _internal_set_command_id(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command_id)
+}
+
+// required bytes command = 2;
+inline bool ClientDownloadRequest_MachOHeaders_LoadCommand::_internal_has_command() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_MachOHeaders_LoadCommand::has_command() const {
+  return _internal_has_command();
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::clear_command() {
+  _impl_.command_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadRequest_MachOHeaders_LoadCommand::command() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command)
+  return _internal_command();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_MachOHeaders_LoadCommand::set_command(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.command_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command)
+}
+inline std::string* ClientDownloadRequest_MachOHeaders_LoadCommand::mutable_command() {
+  std::string* _s = _internal_mutable_command();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_MachOHeaders_LoadCommand::_internal_command() const {
+  return _impl_.command_.Get();
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::_internal_set_command(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.command_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_MachOHeaders_LoadCommand::_internal_mutable_command() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.command_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_MachOHeaders_LoadCommand::release_command() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command)
+  if (!_internal_has_command()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.command_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.command_.IsDefault()) {
+    _impl_.command_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_allocated_command(std::string* command) {
+  if (command != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.command_.SetAllocated(command, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.command_.IsDefault()) {
+    _impl_.command_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_MachOHeaders
+
+// required bytes mach_header = 1;
+inline bool ClientDownloadRequest_MachOHeaders::_internal_has_mach_header() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_MachOHeaders::has_mach_header() const {
+  return _internal_has_mach_header();
+}
+inline void ClientDownloadRequest_MachOHeaders::clear_mach_header() {
+  _impl_.mach_header_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadRequest_MachOHeaders::mach_header() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header)
+  return _internal_mach_header();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_MachOHeaders::set_mach_header(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.mach_header_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header)
+}
+inline std::string* ClientDownloadRequest_MachOHeaders::mutable_mach_header() {
+  std::string* _s = _internal_mutable_mach_header();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_MachOHeaders::_internal_mach_header() const {
+  return _impl_.mach_header_.Get();
+}
+inline void ClientDownloadRequest_MachOHeaders::_internal_set_mach_header(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.mach_header_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_MachOHeaders::_internal_mutable_mach_header() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.mach_header_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_MachOHeaders::release_mach_header() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header)
+  if (!_internal_has_mach_header()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.mach_header_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mach_header_.IsDefault()) {
+    _impl_.mach_header_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_MachOHeaders::set_allocated_mach_header(std::string* mach_header) {
+  if (mach_header != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.mach_header_.SetAllocated(mach_header, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mach_header_.IsDefault()) {
+    _impl_.mach_header_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header)
+}
+
+// repeated .safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand load_commands = 2;
+inline int ClientDownloadRequest_MachOHeaders::_internal_load_commands_size() const {
+  return _impl_.load_commands_.size();
+}
+inline int ClientDownloadRequest_MachOHeaders::load_commands_size() const {
+  return _internal_load_commands_size();
+}
+inline void ClientDownloadRequest_MachOHeaders::clear_load_commands() {
+  _impl_.load_commands_.Clear();
+}
+inline ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand* ClientDownloadRequest_MachOHeaders::mutable_load_commands(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.MachOHeaders.load_commands)
+  return _impl_.load_commands_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand >*
+ClientDownloadRequest_MachOHeaders::mutable_load_commands() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.MachOHeaders.load_commands)
+  return &_impl_.load_commands_;
+}
+inline const ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand& ClientDownloadRequest_MachOHeaders::_internal_load_commands(int index) const {
+  return _impl_.load_commands_.Get(index);
+}
+inline const ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand& ClientDownloadRequest_MachOHeaders::load_commands(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.MachOHeaders.load_commands)
+  return _internal_load_commands(index);
+}
+inline ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand* ClientDownloadRequest_MachOHeaders::_internal_add_load_commands() {
+  return _impl_.load_commands_.Add();
+}
+inline ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand* ClientDownloadRequest_MachOHeaders::add_load_commands() {
+  ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand* _add = _internal_add_load_commands();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.MachOHeaders.load_commands)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand >&
+ClientDownloadRequest_MachOHeaders::load_commands() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.MachOHeaders.load_commands)
+  return _impl_.load_commands_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_ImageHeaders
+
+// optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1;
+inline bool ClientDownloadRequest_ImageHeaders::_internal_has_pe_headers() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.pe_headers_ != nullptr);
+  return value;
+}
+inline bool ClientDownloadRequest_ImageHeaders::has_pe_headers() const {
+  return _internal_has_pe_headers();
+}
+inline void ClientDownloadRequest_ImageHeaders::clear_pe_headers() {
+  if (_impl_.pe_headers_ != nullptr) _impl_.pe_headers_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::safe_browsing::ClientDownloadRequest_PEImageHeaders& ClientDownloadRequest_ImageHeaders::_internal_pe_headers() const {
+  const ::safe_browsing::ClientDownloadRequest_PEImageHeaders* p = _impl_.pe_headers_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest_PEImageHeaders&>(
+      ::safe_browsing::_ClientDownloadRequest_PEImageHeaders_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest_PEImageHeaders& ClientDownloadRequest_ImageHeaders::pe_headers() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ImageHeaders.pe_headers)
+  return _internal_pe_headers();
+}
+inline void ClientDownloadRequest_ImageHeaders::unsafe_arena_set_allocated_pe_headers(
+    ::safe_browsing::ClientDownloadRequest_PEImageHeaders* pe_headers) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pe_headers_);
+  }
+  _impl_.pe_headers_ = pe_headers;
+  if (pe_headers) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientDownloadRequest.ImageHeaders.pe_headers)
+}
+inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders* ClientDownloadRequest_ImageHeaders::release_pe_headers() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::safe_browsing::ClientDownloadRequest_PEImageHeaders* temp = _impl_.pe_headers_;
+  _impl_.pe_headers_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders* ClientDownloadRequest_ImageHeaders::unsafe_arena_release_pe_headers() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.ImageHeaders.pe_headers)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::safe_browsing::ClientDownloadRequest_PEImageHeaders* temp = _impl_.pe_headers_;
+  _impl_.pe_headers_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders* ClientDownloadRequest_ImageHeaders::_internal_mutable_pe_headers() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.pe_headers_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_PEImageHeaders>(GetArenaForAllocation());
+    _impl_.pe_headers_ = p;
+  }
+  return _impl_.pe_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders* ClientDownloadRequest_ImageHeaders::mutable_pe_headers() {
+  ::safe_browsing::ClientDownloadRequest_PEImageHeaders* _msg = _internal_mutable_pe_headers();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ImageHeaders.pe_headers)
+  return _msg;
+}
+inline void ClientDownloadRequest_ImageHeaders::set_allocated_pe_headers(::safe_browsing::ClientDownloadRequest_PEImageHeaders* pe_headers) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.pe_headers_;
+  }
+  if (pe_headers) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pe_headers);
+    if (message_arena != submessage_arena) {
+      pe_headers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, pe_headers, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.pe_headers_ = pe_headers;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.ImageHeaders.pe_headers)
+}
+
+// repeated .safe_browsing.ClientDownloadRequest.MachOHeaders mach_o_headers = 2;
+inline int ClientDownloadRequest_ImageHeaders::_internal_mach_o_headers_size() const {
+  return _impl_.mach_o_headers_.size();
+}
+inline int ClientDownloadRequest_ImageHeaders::mach_o_headers_size() const {
+  return _internal_mach_o_headers_size();
+}
+inline void ClientDownloadRequest_ImageHeaders::clear_mach_o_headers() {
+  _impl_.mach_o_headers_.Clear();
+}
+inline ::safe_browsing::ClientDownloadRequest_MachOHeaders* ClientDownloadRequest_ImageHeaders::mutable_mach_o_headers(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ImageHeaders.mach_o_headers)
+  return _impl_.mach_o_headers_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders >*
+ClientDownloadRequest_ImageHeaders::mutable_mach_o_headers() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.ImageHeaders.mach_o_headers)
+  return &_impl_.mach_o_headers_;
+}
+inline const ::safe_browsing::ClientDownloadRequest_MachOHeaders& ClientDownloadRequest_ImageHeaders::_internal_mach_o_headers(int index) const {
+  return _impl_.mach_o_headers_.Get(index);
+}
+inline const ::safe_browsing::ClientDownloadRequest_MachOHeaders& ClientDownloadRequest_ImageHeaders::mach_o_headers(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ImageHeaders.mach_o_headers)
+  return _internal_mach_o_headers(index);
+}
+inline ::safe_browsing::ClientDownloadRequest_MachOHeaders* ClientDownloadRequest_ImageHeaders::_internal_add_mach_o_headers() {
+  return _impl_.mach_o_headers_.Add();
+}
+inline ::safe_browsing::ClientDownloadRequest_MachOHeaders* ClientDownloadRequest_ImageHeaders::add_mach_o_headers() {
+  ::safe_browsing::ClientDownloadRequest_MachOHeaders* _add = _internal_add_mach_o_headers();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.ImageHeaders.mach_o_headers)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders >&
+ClientDownloadRequest_ImageHeaders::mach_o_headers() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.ImageHeaders.mach_o_headers)
+  return _impl_.mach_o_headers_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_ArchivedBinary
+
+// optional string file_basename = 1;
+inline bool ClientDownloadRequest_ArchivedBinary::_internal_has_file_basename() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_ArchivedBinary::has_file_basename() const {
+  return _internal_has_file_basename();
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_file_basename() {
+  _impl_.file_basename_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadRequest_ArchivedBinary::file_basename() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename)
+  return _internal_file_basename();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest_ArchivedBinary::set_file_basename(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.file_basename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename)
+}
+inline std::string* ClientDownloadRequest_ArchivedBinary::mutable_file_basename() {
+  std::string* _s = _internal_mutable_file_basename();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest_ArchivedBinary::_internal_file_basename() const {
+  return _impl_.file_basename_.Get();
+}
+inline void ClientDownloadRequest_ArchivedBinary::_internal_set_file_basename(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.file_basename_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_ArchivedBinary::_internal_mutable_file_basename() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.file_basename_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest_ArchivedBinary::release_file_basename() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename)
+  if (!_internal_has_file_basename()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.file_basename_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.file_basename_.IsDefault()) {
+    _impl_.file_basename_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_allocated_file_basename(std::string* file_basename) {
+  if (file_basename != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.file_basename_.SetAllocated(file_basename, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.file_basename_.IsDefault()) {
+    _impl_.file_basename_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 2;
+inline bool ClientDownloadRequest_ArchivedBinary::_internal_has_download_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_ArchivedBinary::has_download_type() const {
+  return _internal_has_download_type();
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_download_type() {
+  _impl_.download_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline ::safe_browsing::ClientDownloadRequest_DownloadType ClientDownloadRequest_ArchivedBinary::_internal_download_type() const {
+  return static_cast< ::safe_browsing::ClientDownloadRequest_DownloadType >(_impl_.download_type_);
+}
+inline ::safe_browsing::ClientDownloadRequest_DownloadType ClientDownloadRequest_ArchivedBinary::download_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ArchivedBinary.download_type)
+  return _internal_download_type();
+}
+inline void ClientDownloadRequest_ArchivedBinary::_internal_set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value) {
+  assert(::safe_browsing::ClientDownloadRequest_DownloadType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.download_type_ = value;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value) {
+  _internal_set_download_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.ArchivedBinary.download_type)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.Digests digests = 3;
+inline bool ClientDownloadRequest_ArchivedBinary::_internal_has_digests() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.digests_ != nullptr);
+  return value;
+}
+inline bool ClientDownloadRequest_ArchivedBinary::has_digests() const {
+  return _internal_has_digests();
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_digests() {
+  if (_impl_.digests_ != nullptr) _impl_.digests_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::safe_browsing::ClientDownloadRequest_Digests& ClientDownloadRequest_ArchivedBinary::_internal_digests() const {
+  const ::safe_browsing::ClientDownloadRequest_Digests* p = _impl_.digests_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest_Digests&>(
+      ::safe_browsing::_ClientDownloadRequest_Digests_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest_Digests& ClientDownloadRequest_ArchivedBinary::digests() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ArchivedBinary.digests)
+  return _internal_digests();
+}
+inline void ClientDownloadRequest_ArchivedBinary::unsafe_arena_set_allocated_digests(
+    ::safe_browsing::ClientDownloadRequest_Digests* digests) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.digests_);
+  }
+  _impl_.digests_ = digests;
+  if (digests) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientDownloadRequest.ArchivedBinary.digests)
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest_ArchivedBinary::release_digests() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadRequest_Digests* temp = _impl_.digests_;
+  _impl_.digests_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest_ArchivedBinary::unsafe_arena_release_digests() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.ArchivedBinary.digests)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadRequest_Digests* temp = _impl_.digests_;
+  _impl_.digests_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest_ArchivedBinary::_internal_mutable_digests() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.digests_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_Digests>(GetArenaForAllocation());
+    _impl_.digests_ = p;
+  }
+  return _impl_.digests_;
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest_ArchivedBinary::mutable_digests() {
+  ::safe_browsing::ClientDownloadRequest_Digests* _msg = _internal_mutable_digests();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ArchivedBinary.digests)
+  return _msg;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_allocated_digests(::safe_browsing::ClientDownloadRequest_Digests* digests) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.digests_;
+  }
+  if (digests) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(digests);
+    if (message_arena != submessage_arena) {
+      digests = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, digests, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.digests_ = digests;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.ArchivedBinary.digests)
+}
+
+// optional int64 length = 4;
+inline bool ClientDownloadRequest_ArchivedBinary::_internal_has_length() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest_ArchivedBinary::has_length() const {
+  return _internal_has_length();
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_length() {
+  _impl_.length_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline int64_t ClientDownloadRequest_ArchivedBinary::_internal_length() const {
+  return _impl_.length_;
+}
+inline int64_t ClientDownloadRequest_ArchivedBinary::length() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ArchivedBinary.length)
+  return _internal_length();
+}
+inline void ClientDownloadRequest_ArchivedBinary::_internal_set_length(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.length_ = value;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_length(int64_t value) {
+  _internal_set_length(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.ArchivedBinary.length)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+inline bool ClientDownloadRequest_ArchivedBinary::_internal_has_signature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.signature_ != nullptr);
+  return value;
+}
+inline bool ClientDownloadRequest_ArchivedBinary::has_signature() const {
+  return _internal_has_signature();
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_signature() {
+  if (_impl_.signature_ != nullptr) _impl_.signature_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientDownloadRequest_ArchivedBinary::_internal_signature() const {
+  const ::safe_browsing::ClientDownloadRequest_SignatureInfo* p = _impl_.signature_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest_SignatureInfo&>(
+      ::safe_browsing::_ClientDownloadRequest_SignatureInfo_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientDownloadRequest_ArchivedBinary::signature() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ArchivedBinary.signature)
+  return _internal_signature();
+}
+inline void ClientDownloadRequest_ArchivedBinary::unsafe_arena_set_allocated_signature(
+    ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.signature_);
+  }
+  _impl_.signature_ = signature;
+  if (signature) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientDownloadRequest.ArchivedBinary.signature)
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest_ArchivedBinary::release_signature() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = _impl_.signature_;
+  _impl_.signature_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest_ArchivedBinary::unsafe_arena_release_signature() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.ArchivedBinary.signature)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = _impl_.signature_;
+  _impl_.signature_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest_ArchivedBinary::_internal_mutable_signature() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.signature_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_SignatureInfo>(GetArenaForAllocation());
+    _impl_.signature_ = p;
+  }
+  return _impl_.signature_;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest_ArchivedBinary::mutable_signature() {
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* _msg = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ArchivedBinary.signature)
+  return _msg;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.signature_;
+  }
+  if (signature) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(signature);
+    if (message_arena != submessage_arena) {
+      signature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, signature, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.signature_ = signature;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.ArchivedBinary.signature)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+inline bool ClientDownloadRequest_ArchivedBinary::_internal_has_image_headers() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.image_headers_ != nullptr);
+  return value;
+}
+inline bool ClientDownloadRequest_ArchivedBinary::has_image_headers() const {
+  return _internal_has_image_headers();
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_image_headers() {
+  if (_impl_.image_headers_ != nullptr) _impl_.image_headers_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientDownloadRequest_ArchivedBinary::_internal_image_headers() const {
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders* p = _impl_.image_headers_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest_ImageHeaders&>(
+      ::safe_browsing::_ClientDownloadRequest_ImageHeaders_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientDownloadRequest_ArchivedBinary::image_headers() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ArchivedBinary.image_headers)
+  return _internal_image_headers();
+}
+inline void ClientDownloadRequest_ArchivedBinary::unsafe_arena_set_allocated_image_headers(
+    ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.image_headers_);
+  }
+  _impl_.image_headers_ = image_headers;
+  if (image_headers) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientDownloadRequest.ArchivedBinary.image_headers)
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest_ArchivedBinary::release_image_headers() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = _impl_.image_headers_;
+  _impl_.image_headers_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest_ArchivedBinary::unsafe_arena_release_image_headers() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.ArchivedBinary.image_headers)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = _impl_.image_headers_;
+  _impl_.image_headers_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest_ArchivedBinary::_internal_mutable_image_headers() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.image_headers_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_ImageHeaders>(GetArenaForAllocation());
+    _impl_.image_headers_ = p;
+  }
+  return _impl_.image_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest_ArchivedBinary::mutable_image_headers() {
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* _msg = _internal_mutable_image_headers();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ArchivedBinary.image_headers)
+  return _msg;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.image_headers_;
+  }
+  if (image_headers) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(image_headers);
+    if (message_arena != submessage_arena) {
+      image_headers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, image_headers, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.image_headers_ = image_headers;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.ArchivedBinary.image_headers)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest
+
+// required string url = 1;
+inline bool ClientDownloadRequest::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest::has_url() const {
+  return _internal_has_url();
+}
+inline void ClientDownloadRequest::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadRequest::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.url)
+}
+inline std::string* ClientDownloadRequest::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.url)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void ClientDownloadRequest::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest::release_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.url)
+}
+
+// required .safe_browsing.ClientDownloadRequest.Digests digests = 2;
+inline bool ClientDownloadRequest::_internal_has_digests() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.digests_ != nullptr);
+  return value;
+}
+inline bool ClientDownloadRequest::has_digests() const {
+  return _internal_has_digests();
+}
+inline void ClientDownloadRequest::clear_digests() {
+  if (_impl_.digests_ != nullptr) _impl_.digests_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::safe_browsing::ClientDownloadRequest_Digests& ClientDownloadRequest::_internal_digests() const {
+  const ::safe_browsing::ClientDownloadRequest_Digests* p = _impl_.digests_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest_Digests&>(
+      ::safe_browsing::_ClientDownloadRequest_Digests_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest_Digests& ClientDownloadRequest::digests() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.digests)
+  return _internal_digests();
+}
+inline void ClientDownloadRequest::unsafe_arena_set_allocated_digests(
+    ::safe_browsing::ClientDownloadRequest_Digests* digests) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.digests_);
+  }
+  _impl_.digests_ = digests;
+  if (digests) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientDownloadRequest.digests)
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest::release_digests() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::safe_browsing::ClientDownloadRequest_Digests* temp = _impl_.digests_;
+  _impl_.digests_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest::unsafe_arena_release_digests() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.digests)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::safe_browsing::ClientDownloadRequest_Digests* temp = _impl_.digests_;
+  _impl_.digests_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest::_internal_mutable_digests() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.digests_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_Digests>(GetArenaForAllocation());
+    _impl_.digests_ = p;
+  }
+  return _impl_.digests_;
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest::mutable_digests() {
+  ::safe_browsing::ClientDownloadRequest_Digests* _msg = _internal_mutable_digests();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.digests)
+  return _msg;
+}
+inline void ClientDownloadRequest::set_allocated_digests(::safe_browsing::ClientDownloadRequest_Digests* digests) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.digests_;
+  }
+  if (digests) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(digests);
+    if (message_arena != submessage_arena) {
+      digests = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, digests, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.digests_ = digests;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.digests)
+}
+
+// required int64 length = 3;
+inline bool ClientDownloadRequest::_internal_has_length() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest::has_length() const {
+  return _internal_has_length();
+}
+inline void ClientDownloadRequest::clear_length() {
+  _impl_.length_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline int64_t ClientDownloadRequest::_internal_length() const {
+  return _impl_.length_;
+}
+inline int64_t ClientDownloadRequest::length() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.length)
+  return _internal_length();
+}
+inline void ClientDownloadRequest::_internal_set_length(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.length_ = value;
+}
+inline void ClientDownloadRequest::set_length(int64_t value) {
+  _internal_set_length(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.length)
+}
+
+// repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4;
+inline int ClientDownloadRequest::_internal_resources_size() const {
+  return _impl_.resources_.size();
+}
+inline int ClientDownloadRequest::resources_size() const {
+  return _internal_resources_size();
+}
+inline void ClientDownloadRequest::clear_resources() {
+  _impl_.resources_.Clear();
+}
+inline ::safe_browsing::ClientDownloadRequest_Resource* ClientDownloadRequest::mutable_resources(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.resources)
+  return _impl_.resources_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource >*
+ClientDownloadRequest::mutable_resources() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.resources)
+  return &_impl_.resources_;
+}
+inline const ::safe_browsing::ClientDownloadRequest_Resource& ClientDownloadRequest::_internal_resources(int index) const {
+  return _impl_.resources_.Get(index);
+}
+inline const ::safe_browsing::ClientDownloadRequest_Resource& ClientDownloadRequest::resources(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.resources)
+  return _internal_resources(index);
+}
+inline ::safe_browsing::ClientDownloadRequest_Resource* ClientDownloadRequest::_internal_add_resources() {
+  return _impl_.resources_.Add();
+}
+inline ::safe_browsing::ClientDownloadRequest_Resource* ClientDownloadRequest::add_resources() {
+  ::safe_browsing::ClientDownloadRequest_Resource* _add = _internal_add_resources();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.resources)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource >&
+ClientDownloadRequest::resources() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.resources)
+  return _impl_.resources_;
+}
+
+// optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+inline bool ClientDownloadRequest::_internal_has_signature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.signature_ != nullptr);
+  return value;
+}
+inline bool ClientDownloadRequest::has_signature() const {
+  return _internal_has_signature();
+}
+inline void ClientDownloadRequest::clear_signature() {
+  if (_impl_.signature_ != nullptr) _impl_.signature_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientDownloadRequest::_internal_signature() const {
+  const ::safe_browsing::ClientDownloadRequest_SignatureInfo* p = _impl_.signature_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest_SignatureInfo&>(
+      ::safe_browsing::_ClientDownloadRequest_SignatureInfo_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientDownloadRequest::signature() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.signature)
+  return _internal_signature();
+}
+inline void ClientDownloadRequest::unsafe_arena_set_allocated_signature(
+    ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.signature_);
+  }
+  _impl_.signature_ = signature;
+  if (signature) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientDownloadRequest.signature)
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest::release_signature() {
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = _impl_.signature_;
+  _impl_.signature_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest::unsafe_arena_release_signature() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.signature)
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = _impl_.signature_;
+  _impl_.signature_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest::_internal_mutable_signature() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.signature_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_SignatureInfo>(GetArenaForAllocation());
+    _impl_.signature_ = p;
+  }
+  return _impl_.signature_;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest::mutable_signature() {
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* _msg = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.signature)
+  return _msg;
+}
+inline void ClientDownloadRequest::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.signature_;
+  }
+  if (signature) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(signature);
+    if (message_arena != submessage_arena) {
+      signature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, signature, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.signature_ = signature;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.signature)
+}
+
+// optional bool user_initiated = 6;
+inline bool ClientDownloadRequest::_internal_has_user_initiated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest::has_user_initiated() const {
+  return _internal_has_user_initiated();
+}
+inline void ClientDownloadRequest::clear_user_initiated() {
+  _impl_.user_initiated_ = false;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline bool ClientDownloadRequest::_internal_user_initiated() const {
+  return _impl_.user_initiated_;
+}
+inline bool ClientDownloadRequest::user_initiated() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.user_initiated)
+  return _internal_user_initiated();
+}
+inline void ClientDownloadRequest::_internal_set_user_initiated(bool value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.user_initiated_ = value;
+}
+inline void ClientDownloadRequest::set_user_initiated(bool value) {
+  _internal_set_user_initiated(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.user_initiated)
+}
+
+// optional string file_basename = 9;
+inline bool ClientDownloadRequest::_internal_has_file_basename() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest::has_file_basename() const {
+  return _internal_has_file_basename();
+}
+inline void ClientDownloadRequest::clear_file_basename() {
+  _impl_.file_basename_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientDownloadRequest::file_basename() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.file_basename)
+  return _internal_file_basename();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest::set_file_basename(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.file_basename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.file_basename)
+}
+inline std::string* ClientDownloadRequest::mutable_file_basename() {
+  std::string* _s = _internal_mutable_file_basename();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.file_basename)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest::_internal_file_basename() const {
+  return _impl_.file_basename_.Get();
+}
+inline void ClientDownloadRequest::_internal_set_file_basename(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.file_basename_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest::_internal_mutable_file_basename() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.file_basename_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest::release_file_basename() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.file_basename)
+  if (!_internal_has_file_basename()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.file_basename_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.file_basename_.IsDefault()) {
+    _impl_.file_basename_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest::set_allocated_file_basename(std::string* file_basename) {
+  if (file_basename != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.file_basename_.SetAllocated(file_basename, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.file_basename_.IsDefault()) {
+    _impl_.file_basename_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.file_basename)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 10 [default = WIN_EXECUTABLE];
+inline bool ClientDownloadRequest::_internal_has_download_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest::has_download_type() const {
+  return _internal_has_download_type();
+}
+inline void ClientDownloadRequest::clear_download_type() {
+  _impl_.download_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline ::safe_browsing::ClientDownloadRequest_DownloadType ClientDownloadRequest::_internal_download_type() const {
+  return static_cast< ::safe_browsing::ClientDownloadRequest_DownloadType >(_impl_.download_type_);
+}
+inline ::safe_browsing::ClientDownloadRequest_DownloadType ClientDownloadRequest::download_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.download_type)
+  return _internal_download_type();
+}
+inline void ClientDownloadRequest::_internal_set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value) {
+  assert(::safe_browsing::ClientDownloadRequest_DownloadType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.download_type_ = value;
+}
+inline void ClientDownloadRequest::set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value) {
+  _internal_set_download_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.download_type)
+}
+
+// optional string locale = 11;
+inline bool ClientDownloadRequest::_internal_has_locale() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest::has_locale() const {
+  return _internal_has_locale();
+}
+inline void ClientDownloadRequest::clear_locale() {
+  _impl_.locale_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientDownloadRequest::locale() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.locale)
+  return _internal_locale();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest::set_locale(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.locale_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.locale)
+}
+inline std::string* ClientDownloadRequest::mutable_locale() {
+  std::string* _s = _internal_mutable_locale();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.locale)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest::_internal_locale() const {
+  return _impl_.locale_.Get();
+}
+inline void ClientDownloadRequest::_internal_set_locale(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.locale_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest::_internal_mutable_locale() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.locale_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest::release_locale() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.locale)
+  if (!_internal_has_locale()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.locale_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.locale_.IsDefault()) {
+    _impl_.locale_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest::set_allocated_locale(std::string* locale) {
+  if (locale != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.locale_.SetAllocated(locale, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.locale_.IsDefault()) {
+    _impl_.locale_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.locale)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 18;
+inline bool ClientDownloadRequest::_internal_has_image_headers() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.image_headers_ != nullptr);
+  return value;
+}
+inline bool ClientDownloadRequest::has_image_headers() const {
+  return _internal_has_image_headers();
+}
+inline void ClientDownloadRequest::clear_image_headers() {
+  if (_impl_.image_headers_ != nullptr) _impl_.image_headers_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientDownloadRequest::_internal_image_headers() const {
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders* p = _impl_.image_headers_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest_ImageHeaders&>(
+      ::safe_browsing::_ClientDownloadRequest_ImageHeaders_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientDownloadRequest::image_headers() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.image_headers)
+  return _internal_image_headers();
+}
+inline void ClientDownloadRequest::unsafe_arena_set_allocated_image_headers(
+    ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.image_headers_);
+  }
+  _impl_.image_headers_ = image_headers;
+  if (image_headers) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientDownloadRequest.image_headers)
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest::release_image_headers() {
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = _impl_.image_headers_;
+  _impl_.image_headers_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest::unsafe_arena_release_image_headers() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.image_headers)
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = _impl_.image_headers_;
+  _impl_.image_headers_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest::_internal_mutable_image_headers() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  if (_impl_.image_headers_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_ImageHeaders>(GetArenaForAllocation());
+    _impl_.image_headers_ = p;
+  }
+  return _impl_.image_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest::mutable_image_headers() {
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* _msg = _internal_mutable_image_headers();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.image_headers)
+  return _msg;
+}
+inline void ClientDownloadRequest::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.image_headers_;
+  }
+  if (image_headers) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(image_headers);
+    if (message_arena != submessage_arena) {
+      image_headers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, image_headers, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.image_headers_ = image_headers;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.image_headers)
+}
+
+// repeated .safe_browsing.ClientDownloadRequest.ArchivedBinary archived_binary = 22;
+inline int ClientDownloadRequest::_internal_archived_binary_size() const {
+  return _impl_.archived_binary_.size();
+}
+inline int ClientDownloadRequest::archived_binary_size() const {
+  return _internal_archived_binary_size();
+}
+inline void ClientDownloadRequest::clear_archived_binary() {
+  _impl_.archived_binary_.Clear();
+}
+inline ::safe_browsing::ClientDownloadRequest_ArchivedBinary* ClientDownloadRequest::mutable_archived_binary(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.archived_binary)
+  return _impl_.archived_binary_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ArchivedBinary >*
+ClientDownloadRequest::mutable_archived_binary() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.archived_binary)
+  return &_impl_.archived_binary_;
+}
+inline const ::safe_browsing::ClientDownloadRequest_ArchivedBinary& ClientDownloadRequest::_internal_archived_binary(int index) const {
+  return _impl_.archived_binary_.Get(index);
+}
+inline const ::safe_browsing::ClientDownloadRequest_ArchivedBinary& ClientDownloadRequest::archived_binary(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.archived_binary)
+  return _internal_archived_binary(index);
+}
+inline ::safe_browsing::ClientDownloadRequest_ArchivedBinary* ClientDownloadRequest::_internal_add_archived_binary() {
+  return _impl_.archived_binary_.Add();
+}
+inline ::safe_browsing::ClientDownloadRequest_ArchivedBinary* ClientDownloadRequest::add_archived_binary() {
+  ::safe_browsing::ClientDownloadRequest_ArchivedBinary* _add = _internal_add_archived_binary();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.archived_binary)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ArchivedBinary >&
+ClientDownloadRequest::archived_binary() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.archived_binary)
+  return _impl_.archived_binary_;
+}
+
+// optional .safe_browsing.ChromeUserPopulation population = 24;
+inline bool ClientDownloadRequest::_internal_has_population() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.population_ != nullptr);
+  return value;
+}
+inline bool ClientDownloadRequest::has_population() const {
+  return _internal_has_population();
+}
+inline void ClientDownloadRequest::clear_population() {
+  if (_impl_.population_ != nullptr) _impl_.population_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const ::safe_browsing::ChromeUserPopulation& ClientDownloadRequest::_internal_population() const {
+  const ::safe_browsing::ChromeUserPopulation* p = _impl_.population_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ChromeUserPopulation&>(
+      ::safe_browsing::_ChromeUserPopulation_default_instance_);
+}
+inline const ::safe_browsing::ChromeUserPopulation& ClientDownloadRequest::population() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.population)
+  return _internal_population();
+}
+inline void ClientDownloadRequest::unsafe_arena_set_allocated_population(
+    ::safe_browsing::ChromeUserPopulation* population) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.population_);
+  }
+  _impl_.population_ = population;
+  if (population) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientDownloadRequest.population)
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientDownloadRequest::release_population() {
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::safe_browsing::ChromeUserPopulation* temp = _impl_.population_;
+  _impl_.population_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientDownloadRequest::unsafe_arena_release_population() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.population)
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  ::safe_browsing::ChromeUserPopulation* temp = _impl_.population_;
+  _impl_.population_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientDownloadRequest::_internal_mutable_population() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  if (_impl_.population_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ChromeUserPopulation>(GetArenaForAllocation());
+    _impl_.population_ = p;
+  }
+  return _impl_.population_;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientDownloadRequest::mutable_population() {
+  ::safe_browsing::ChromeUserPopulation* _msg = _internal_mutable_population();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.population)
+  return _msg;
+}
+inline void ClientDownloadRequest::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.population_;
+  }
+  if (population) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(population);
+    if (message_arena != submessage_arena) {
+      population = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, population, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.population_ = population;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.population)
+}
+
+// optional bool archive_valid = 26;
+inline bool ClientDownloadRequest::_internal_has_archive_valid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest::has_archive_valid() const {
+  return _internal_has_archive_valid();
+}
+inline void ClientDownloadRequest::clear_archive_valid() {
+  _impl_.archive_valid_ = false;
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline bool ClientDownloadRequest::_internal_archive_valid() const {
+  return _impl_.archive_valid_;
+}
+inline bool ClientDownloadRequest::archive_valid() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.archive_valid)
+  return _internal_archive_valid();
+}
+inline void ClientDownloadRequest::_internal_set_archive_valid(bool value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.archive_valid_ = value;
+}
+inline void ClientDownloadRequest::set_archive_valid(bool value) {
+  _internal_set_archive_valid(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.archive_valid)
+}
+
+// optional bool skipped_url_whitelist = 28;
+inline bool ClientDownloadRequest::_internal_has_skipped_url_whitelist() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest::has_skipped_url_whitelist() const {
+  return _internal_has_skipped_url_whitelist();
+}
+inline void ClientDownloadRequest::clear_skipped_url_whitelist() {
+  _impl_.skipped_url_whitelist_ = false;
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline bool ClientDownloadRequest::_internal_skipped_url_whitelist() const {
+  return _impl_.skipped_url_whitelist_;
+}
+inline bool ClientDownloadRequest::skipped_url_whitelist() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.skipped_url_whitelist)
+  return _internal_skipped_url_whitelist();
+}
+inline void ClientDownloadRequest::_internal_set_skipped_url_whitelist(bool value) {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  _impl_.skipped_url_whitelist_ = value;
+}
+inline void ClientDownloadRequest::set_skipped_url_whitelist(bool value) {
+  _internal_set_skipped_url_whitelist(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.skipped_url_whitelist)
+}
+
+// optional bool skipped_certificate_whitelist = 31;
+inline bool ClientDownloadRequest::_internal_has_skipped_certificate_whitelist() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest::has_skipped_certificate_whitelist() const {
+  return _internal_has_skipped_certificate_whitelist();
+}
+inline void ClientDownloadRequest::clear_skipped_certificate_whitelist() {
+  _impl_.skipped_certificate_whitelist_ = false;
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline bool ClientDownloadRequest::_internal_skipped_certificate_whitelist() const {
+  return _impl_.skipped_certificate_whitelist_;
+}
+inline bool ClientDownloadRequest::skipped_certificate_whitelist() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.skipped_certificate_whitelist)
+  return _internal_skipped_certificate_whitelist();
+}
+inline void ClientDownloadRequest::_internal_set_skipped_certificate_whitelist(bool value) {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  _impl_.skipped_certificate_whitelist_ = value;
+}
+inline void ClientDownloadRequest::set_skipped_certificate_whitelist(bool value) {
+  _internal_set_skipped_certificate_whitelist(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.skipped_certificate_whitelist)
+}
+
+// repeated string alternate_extensions = 35;
+inline int ClientDownloadRequest::_internal_alternate_extensions_size() const {
+  return _impl_.alternate_extensions_.size();
+}
+inline int ClientDownloadRequest::alternate_extensions_size() const {
+  return _internal_alternate_extensions_size();
+}
+inline void ClientDownloadRequest::clear_alternate_extensions() {
+  _impl_.alternate_extensions_.Clear();
+}
+inline std::string* ClientDownloadRequest::add_alternate_extensions() {
+  std::string* _s = _internal_add_alternate_extensions();
+  // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientDownloadRequest.alternate_extensions)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest::_internal_alternate_extensions(int index) const {
+  return _impl_.alternate_extensions_.Get(index);
+}
+inline const std::string& ClientDownloadRequest::alternate_extensions(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.alternate_extensions)
+  return _internal_alternate_extensions(index);
+}
+inline std::string* ClientDownloadRequest::mutable_alternate_extensions(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.alternate_extensions)
+  return _impl_.alternate_extensions_.Mutable(index);
+}
+inline void ClientDownloadRequest::set_alternate_extensions(int index, const std::string& value) {
+  _impl_.alternate_extensions_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.alternate_extensions)
+}
+inline void ClientDownloadRequest::set_alternate_extensions(int index, std::string&& value) {
+  _impl_.alternate_extensions_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.alternate_extensions)
+}
+inline void ClientDownloadRequest::set_alternate_extensions(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.alternate_extensions_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.alternate_extensions)
+}
+inline void ClientDownloadRequest::set_alternate_extensions(int index, const char* value, size_t size) {
+  _impl_.alternate_extensions_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.alternate_extensions)
+}
+inline std::string* ClientDownloadRequest::_internal_add_alternate_extensions() {
+  return _impl_.alternate_extensions_.Add();
+}
+inline void ClientDownloadRequest::add_alternate_extensions(const std::string& value) {
+  _impl_.alternate_extensions_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.alternate_extensions)
+}
+inline void ClientDownloadRequest::add_alternate_extensions(std::string&& value) {
+  _impl_.alternate_extensions_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.alternate_extensions)
+}
+inline void ClientDownloadRequest::add_alternate_extensions(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.alternate_extensions_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:safe_browsing.ClientDownloadRequest.alternate_extensions)
+}
+inline void ClientDownloadRequest::add_alternate_extensions(const char* value, size_t size) {
+  _impl_.alternate_extensions_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:safe_browsing.ClientDownloadRequest.alternate_extensions)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ClientDownloadRequest::alternate_extensions() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.alternate_extensions)
+  return _impl_.alternate_extensions_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ClientDownloadRequest::mutable_alternate_extensions() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.alternate_extensions)
+  return &_impl_.alternate_extensions_;
+}
+
+// repeated .safe_browsing.ReferrerChainEntry referrer_chain = 36;
+inline int ClientDownloadRequest::_internal_referrer_chain_size() const {
+  return _impl_.referrer_chain_.size();
+}
+inline int ClientDownloadRequest::referrer_chain_size() const {
+  return _internal_referrer_chain_size();
+}
+inline void ClientDownloadRequest::clear_referrer_chain() {
+  _impl_.referrer_chain_.Clear();
+}
+inline ::safe_browsing::ReferrerChainEntry* ClientDownloadRequest::mutable_referrer_chain(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.referrer_chain)
+  return _impl_.referrer_chain_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry >*
+ClientDownloadRequest::mutable_referrer_chain() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.referrer_chain)
+  return &_impl_.referrer_chain_;
+}
+inline const ::safe_browsing::ReferrerChainEntry& ClientDownloadRequest::_internal_referrer_chain(int index) const {
+  return _impl_.referrer_chain_.Get(index);
+}
+inline const ::safe_browsing::ReferrerChainEntry& ClientDownloadRequest::referrer_chain(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.referrer_chain)
+  return _internal_referrer_chain(index);
+}
+inline ::safe_browsing::ReferrerChainEntry* ClientDownloadRequest::_internal_add_referrer_chain() {
+  return _impl_.referrer_chain_.Add();
+}
+inline ::safe_browsing::ReferrerChainEntry* ClientDownloadRequest::add_referrer_chain() {
+  ::safe_browsing::ReferrerChainEntry* _add = _internal_add_referrer_chain();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.referrer_chain)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry >&
+ClientDownloadRequest::referrer_chain() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.referrer_chain)
+  return _impl_.referrer_chain_;
+}
+
+// optional bool DEPRECATED_download_attribution_finch_enabled = 39 [deprecated = true];
+inline bool ClientDownloadRequest::_internal_has_deprecated_download_attribution_finch_enabled() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest::has_deprecated_download_attribution_finch_enabled() const {
+  return _internal_has_deprecated_download_attribution_finch_enabled();
+}
+inline void ClientDownloadRequest::clear_deprecated_download_attribution_finch_enabled() {
+  _impl_.deprecated_download_attribution_finch_enabled_ = false;
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline bool ClientDownloadRequest::_internal_deprecated_download_attribution_finch_enabled() const {
+  return _impl_.deprecated_download_attribution_finch_enabled_;
+}
+inline bool ClientDownloadRequest::deprecated_download_attribution_finch_enabled() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.DEPRECATED_download_attribution_finch_enabled)
+  return _internal_deprecated_download_attribution_finch_enabled();
+}
+inline void ClientDownloadRequest::_internal_set_deprecated_download_attribution_finch_enabled(bool value) {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  _impl_.deprecated_download_attribution_finch_enabled_ = value;
+}
+inline void ClientDownloadRequest::set_deprecated_download_attribution_finch_enabled(bool value) {
+  _internal_set_deprecated_download_attribution_finch_enabled(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.DEPRECATED_download_attribution_finch_enabled)
+}
+
+// optional bytes udif_code_signature = 40;
+inline bool ClientDownloadRequest::_internal_has_udif_code_signature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientDownloadRequest::has_udif_code_signature() const {
+  return _internal_has_udif_code_signature();
+}
+inline void ClientDownloadRequest::clear_udif_code_signature() {
+  _impl_.udif_code_signature_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ClientDownloadRequest::udif_code_signature() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.udif_code_signature)
+  return _internal_udif_code_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadRequest::set_udif_code_signature(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.udif_code_signature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.udif_code_signature)
+}
+inline std::string* ClientDownloadRequest::mutable_udif_code_signature() {
+  std::string* _s = _internal_mutable_udif_code_signature();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.udif_code_signature)
+  return _s;
+}
+inline const std::string& ClientDownloadRequest::_internal_udif_code_signature() const {
+  return _impl_.udif_code_signature_.Get();
+}
+inline void ClientDownloadRequest::_internal_set_udif_code_signature(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.udif_code_signature_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest::_internal_mutable_udif_code_signature() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.udif_code_signature_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadRequest::release_udif_code_signature() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.udif_code_signature)
+  if (!_internal_has_udif_code_signature()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.udif_code_signature_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.udif_code_signature_.IsDefault()) {
+    _impl_.udif_code_signature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadRequest::set_allocated_udif_code_signature(std::string* udif_code_signature) {
+  if (udif_code_signature != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.udif_code_signature_.SetAllocated(udif_code_signature, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.udif_code_signature_.IsDefault()) {
+    _impl_.udif_code_signature_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.udif_code_signature)
+}
+
+// -------------------------------------------------------------------
+
+// ReferrerChainEntry_ServerRedirect
+
+// optional string url = 1;
+inline bool ReferrerChainEntry_ServerRedirect::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ReferrerChainEntry_ServerRedirect::has_url() const {
+  return _internal_has_url();
+}
+inline void ReferrerChainEntry_ServerRedirect::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ReferrerChainEntry_ServerRedirect::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ReferrerChainEntry.ServerRedirect.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ReferrerChainEntry_ServerRedirect::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.ServerRedirect.url)
+}
+inline std::string* ReferrerChainEntry_ServerRedirect::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ReferrerChainEntry.ServerRedirect.url)
+  return _s;
+}
+inline const std::string& ReferrerChainEntry_ServerRedirect::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void ReferrerChainEntry_ServerRedirect::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ReferrerChainEntry_ServerRedirect::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ReferrerChainEntry_ServerRedirect::release_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ReferrerChainEntry.ServerRedirect.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ReferrerChainEntry_ServerRedirect::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ReferrerChainEntry.ServerRedirect.url)
+}
+
+// -------------------------------------------------------------------
+
+// ReferrerChainEntry
+
+// optional string url = 1;
+inline bool ReferrerChainEntry::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ReferrerChainEntry::has_url() const {
+  return _internal_has_url();
+}
+inline void ReferrerChainEntry::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ReferrerChainEntry::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ReferrerChainEntry.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ReferrerChainEntry::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.url)
+}
+inline std::string* ReferrerChainEntry::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ReferrerChainEntry.url)
+  return _s;
+}
+inline const std::string& ReferrerChainEntry::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void ReferrerChainEntry::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ReferrerChainEntry::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ReferrerChainEntry::release_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ReferrerChainEntry.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ReferrerChainEntry::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ReferrerChainEntry.url)
+}
+
+// optional string main_frame_url = 9;
+inline bool ReferrerChainEntry::_internal_has_main_frame_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ReferrerChainEntry::has_main_frame_url() const {
+  return _internal_has_main_frame_url();
+}
+inline void ReferrerChainEntry::clear_main_frame_url() {
+  _impl_.main_frame_url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ReferrerChainEntry::main_frame_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ReferrerChainEntry.main_frame_url)
+  return _internal_main_frame_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ReferrerChainEntry::set_main_frame_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.main_frame_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.main_frame_url)
+}
+inline std::string* ReferrerChainEntry::mutable_main_frame_url() {
+  std::string* _s = _internal_mutable_main_frame_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ReferrerChainEntry.main_frame_url)
+  return _s;
+}
+inline const std::string& ReferrerChainEntry::_internal_main_frame_url() const {
+  return _impl_.main_frame_url_.Get();
+}
+inline void ReferrerChainEntry::_internal_set_main_frame_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.main_frame_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ReferrerChainEntry::_internal_mutable_main_frame_url() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.main_frame_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ReferrerChainEntry::release_main_frame_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ReferrerChainEntry.main_frame_url)
+  if (!_internal_has_main_frame_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.main_frame_url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.main_frame_url_.IsDefault()) {
+    _impl_.main_frame_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ReferrerChainEntry::set_allocated_main_frame_url(std::string* main_frame_url) {
+  if (main_frame_url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.main_frame_url_.SetAllocated(main_frame_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.main_frame_url_.IsDefault()) {
+    _impl_.main_frame_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ReferrerChainEntry.main_frame_url)
+}
+
+// optional .safe_browsing.ReferrerChainEntry.URLType type = 2 [default = CLIENT_REDIRECT];
+inline bool ReferrerChainEntry::_internal_has_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ReferrerChainEntry::has_type() const {
+  return _internal_has_type();
+}
+inline void ReferrerChainEntry::clear_type() {
+  _impl_.type_ = 4;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline ::safe_browsing::ReferrerChainEntry_URLType ReferrerChainEntry::_internal_type() const {
+  return static_cast< ::safe_browsing::ReferrerChainEntry_URLType >(_impl_.type_);
+}
+inline ::safe_browsing::ReferrerChainEntry_URLType ReferrerChainEntry::type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ReferrerChainEntry.type)
+  return _internal_type();
+}
+inline void ReferrerChainEntry::_internal_set_type(::safe_browsing::ReferrerChainEntry_URLType value) {
+  assert(::safe_browsing::ReferrerChainEntry_URLType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.type_ = value;
+}
+inline void ReferrerChainEntry::set_type(::safe_browsing::ReferrerChainEntry_URLType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.type)
+}
+
+// repeated string ip_addresses = 3;
+inline int ReferrerChainEntry::_internal_ip_addresses_size() const {
+  return _impl_.ip_addresses_.size();
+}
+inline int ReferrerChainEntry::ip_addresses_size() const {
+  return _internal_ip_addresses_size();
+}
+inline void ReferrerChainEntry::clear_ip_addresses() {
+  _impl_.ip_addresses_.Clear();
+}
+inline std::string* ReferrerChainEntry::add_ip_addresses() {
+  std::string* _s = _internal_add_ip_addresses();
+  // @@protoc_insertion_point(field_add_mutable:safe_browsing.ReferrerChainEntry.ip_addresses)
+  return _s;
+}
+inline const std::string& ReferrerChainEntry::_internal_ip_addresses(int index) const {
+  return _impl_.ip_addresses_.Get(index);
+}
+inline const std::string& ReferrerChainEntry::ip_addresses(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ReferrerChainEntry.ip_addresses)
+  return _internal_ip_addresses(index);
+}
+inline std::string* ReferrerChainEntry::mutable_ip_addresses(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ReferrerChainEntry.ip_addresses)
+  return _impl_.ip_addresses_.Mutable(index);
+}
+inline void ReferrerChainEntry::set_ip_addresses(int index, const std::string& value) {
+  _impl_.ip_addresses_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.ip_addresses)
+}
+inline void ReferrerChainEntry::set_ip_addresses(int index, std::string&& value) {
+  _impl_.ip_addresses_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.ip_addresses)
+}
+inline void ReferrerChainEntry::set_ip_addresses(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.ip_addresses_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ReferrerChainEntry.ip_addresses)
+}
+inline void ReferrerChainEntry::set_ip_addresses(int index, const char* value, size_t size) {
+  _impl_.ip_addresses_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ReferrerChainEntry.ip_addresses)
+}
+inline std::string* ReferrerChainEntry::_internal_add_ip_addresses() {
+  return _impl_.ip_addresses_.Add();
+}
+inline void ReferrerChainEntry::add_ip_addresses(const std::string& value) {
+  _impl_.ip_addresses_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ReferrerChainEntry.ip_addresses)
+}
+inline void ReferrerChainEntry::add_ip_addresses(std::string&& value) {
+  _impl_.ip_addresses_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:safe_browsing.ReferrerChainEntry.ip_addresses)
+}
+inline void ReferrerChainEntry::add_ip_addresses(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.ip_addresses_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:safe_browsing.ReferrerChainEntry.ip_addresses)
+}
+inline void ReferrerChainEntry::add_ip_addresses(const char* value, size_t size) {
+  _impl_.ip_addresses_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:safe_browsing.ReferrerChainEntry.ip_addresses)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ReferrerChainEntry::ip_addresses() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ReferrerChainEntry.ip_addresses)
+  return _impl_.ip_addresses_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ReferrerChainEntry::mutable_ip_addresses() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ReferrerChainEntry.ip_addresses)
+  return &_impl_.ip_addresses_;
+}
+
+// optional string referrer_url = 4;
+inline bool ReferrerChainEntry::_internal_has_referrer_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ReferrerChainEntry::has_referrer_url() const {
+  return _internal_has_referrer_url();
+}
+inline void ReferrerChainEntry::clear_referrer_url() {
+  _impl_.referrer_url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ReferrerChainEntry::referrer_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ReferrerChainEntry.referrer_url)
+  return _internal_referrer_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ReferrerChainEntry::set_referrer_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.referrer_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.referrer_url)
+}
+inline std::string* ReferrerChainEntry::mutable_referrer_url() {
+  std::string* _s = _internal_mutable_referrer_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ReferrerChainEntry.referrer_url)
+  return _s;
+}
+inline const std::string& ReferrerChainEntry::_internal_referrer_url() const {
+  return _impl_.referrer_url_.Get();
+}
+inline void ReferrerChainEntry::_internal_set_referrer_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.referrer_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ReferrerChainEntry::_internal_mutable_referrer_url() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.referrer_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ReferrerChainEntry::release_referrer_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ReferrerChainEntry.referrer_url)
+  if (!_internal_has_referrer_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.referrer_url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_url_.IsDefault()) {
+    _impl_.referrer_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ReferrerChainEntry::set_allocated_referrer_url(std::string* referrer_url) {
+  if (referrer_url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.referrer_url_.SetAllocated(referrer_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_url_.IsDefault()) {
+    _impl_.referrer_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ReferrerChainEntry.referrer_url)
+}
+
+// optional string referrer_main_frame_url = 5;
+inline bool ReferrerChainEntry::_internal_has_referrer_main_frame_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ReferrerChainEntry::has_referrer_main_frame_url() const {
+  return _internal_has_referrer_main_frame_url();
+}
+inline void ReferrerChainEntry::clear_referrer_main_frame_url() {
+  _impl_.referrer_main_frame_url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ReferrerChainEntry::referrer_main_frame_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ReferrerChainEntry.referrer_main_frame_url)
+  return _internal_referrer_main_frame_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ReferrerChainEntry::set_referrer_main_frame_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.referrer_main_frame_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.referrer_main_frame_url)
+}
+inline std::string* ReferrerChainEntry::mutable_referrer_main_frame_url() {
+  std::string* _s = _internal_mutable_referrer_main_frame_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ReferrerChainEntry.referrer_main_frame_url)
+  return _s;
+}
+inline const std::string& ReferrerChainEntry::_internal_referrer_main_frame_url() const {
+  return _impl_.referrer_main_frame_url_.Get();
+}
+inline void ReferrerChainEntry::_internal_set_referrer_main_frame_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.referrer_main_frame_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ReferrerChainEntry::_internal_mutable_referrer_main_frame_url() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.referrer_main_frame_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ReferrerChainEntry::release_referrer_main_frame_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ReferrerChainEntry.referrer_main_frame_url)
+  if (!_internal_has_referrer_main_frame_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.referrer_main_frame_url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_main_frame_url_.IsDefault()) {
+    _impl_.referrer_main_frame_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ReferrerChainEntry::set_allocated_referrer_main_frame_url(std::string* referrer_main_frame_url) {
+  if (referrer_main_frame_url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.referrer_main_frame_url_.SetAllocated(referrer_main_frame_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_main_frame_url_.IsDefault()) {
+    _impl_.referrer_main_frame_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ReferrerChainEntry.referrer_main_frame_url)
+}
+
+// optional bool is_retargeting = 6;
+inline bool ReferrerChainEntry::_internal_has_is_retargeting() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ReferrerChainEntry::has_is_retargeting() const {
+  return _internal_has_is_retargeting();
+}
+inline void ReferrerChainEntry::clear_is_retargeting() {
+  _impl_.is_retargeting_ = false;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline bool ReferrerChainEntry::_internal_is_retargeting() const {
+  return _impl_.is_retargeting_;
+}
+inline bool ReferrerChainEntry::is_retargeting() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ReferrerChainEntry.is_retargeting)
+  return _internal_is_retargeting();
+}
+inline void ReferrerChainEntry::_internal_set_is_retargeting(bool value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.is_retargeting_ = value;
+}
+inline void ReferrerChainEntry::set_is_retargeting(bool value) {
+  _internal_set_is_retargeting(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.is_retargeting)
+}
+
+// optional double navigation_time_msec = 7;
+inline bool ReferrerChainEntry::_internal_has_navigation_time_msec() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ReferrerChainEntry::has_navigation_time_msec() const {
+  return _internal_has_navigation_time_msec();
+}
+inline void ReferrerChainEntry::clear_navigation_time_msec() {
+  _impl_.navigation_time_msec_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline double ReferrerChainEntry::_internal_navigation_time_msec() const {
+  return _impl_.navigation_time_msec_;
+}
+inline double ReferrerChainEntry::navigation_time_msec() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ReferrerChainEntry.navigation_time_msec)
+  return _internal_navigation_time_msec();
+}
+inline void ReferrerChainEntry::_internal_set_navigation_time_msec(double value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.navigation_time_msec_ = value;
+}
+inline void ReferrerChainEntry::set_navigation_time_msec(double value) {
+  _internal_set_navigation_time_msec(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.navigation_time_msec)
+}
+
+// repeated .safe_browsing.ReferrerChainEntry.ServerRedirect server_redirect_chain = 8;
+inline int ReferrerChainEntry::_internal_server_redirect_chain_size() const {
+  return _impl_.server_redirect_chain_.size();
+}
+inline int ReferrerChainEntry::server_redirect_chain_size() const {
+  return _internal_server_redirect_chain_size();
+}
+inline void ReferrerChainEntry::clear_server_redirect_chain() {
+  _impl_.server_redirect_chain_.Clear();
+}
+inline ::safe_browsing::ReferrerChainEntry_ServerRedirect* ReferrerChainEntry::mutable_server_redirect_chain(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ReferrerChainEntry.server_redirect_chain)
+  return _impl_.server_redirect_chain_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry_ServerRedirect >*
+ReferrerChainEntry::mutable_server_redirect_chain() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ReferrerChainEntry.server_redirect_chain)
+  return &_impl_.server_redirect_chain_;
+}
+inline const ::safe_browsing::ReferrerChainEntry_ServerRedirect& ReferrerChainEntry::_internal_server_redirect_chain(int index) const {
+  return _impl_.server_redirect_chain_.Get(index);
+}
+inline const ::safe_browsing::ReferrerChainEntry_ServerRedirect& ReferrerChainEntry::server_redirect_chain(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ReferrerChainEntry.server_redirect_chain)
+  return _internal_server_redirect_chain(index);
+}
+inline ::safe_browsing::ReferrerChainEntry_ServerRedirect* ReferrerChainEntry::_internal_add_server_redirect_chain() {
+  return _impl_.server_redirect_chain_.Add();
+}
+inline ::safe_browsing::ReferrerChainEntry_ServerRedirect* ReferrerChainEntry::add_server_redirect_chain() {
+  ::safe_browsing::ReferrerChainEntry_ServerRedirect* _add = _internal_add_server_redirect_chain();
+  // @@protoc_insertion_point(field_add:safe_browsing.ReferrerChainEntry.server_redirect_chain)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry_ServerRedirect >&
+ReferrerChainEntry::server_redirect_chain() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ReferrerChainEntry.server_redirect_chain)
+  return _impl_.server_redirect_chain_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadResponse_MoreInfo
+
+// optional string description = 1;
+inline bool ClientDownloadResponse_MoreInfo::_internal_has_description() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadResponse_MoreInfo::has_description() const {
+  return _internal_has_description();
+}
+inline void ClientDownloadResponse_MoreInfo::clear_description() {
+  _impl_.description_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadResponse_MoreInfo::description() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadResponse.MoreInfo.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadResponse_MoreInfo::set_description(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadResponse.MoreInfo.description)
+}
+inline std::string* ClientDownloadResponse_MoreInfo::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadResponse.MoreInfo.description)
+  return _s;
+}
+inline const std::string& ClientDownloadResponse_MoreInfo::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void ClientDownloadResponse_MoreInfo::_internal_set_description(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadResponse_MoreInfo::_internal_mutable_description() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadResponse_MoreInfo::release_description() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadResponse.MoreInfo.description)
+  if (!_internal_has_description()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.description_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadResponse_MoreInfo::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadResponse.MoreInfo.description)
+}
+
+// optional string url = 2;
+inline bool ClientDownloadResponse_MoreInfo::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientDownloadResponse_MoreInfo::has_url() const {
+  return _internal_has_url();
+}
+inline void ClientDownloadResponse_MoreInfo::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientDownloadResponse_MoreInfo::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadResponse.MoreInfo.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadResponse_MoreInfo::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadResponse.MoreInfo.url)
+}
+inline std::string* ClientDownloadResponse_MoreInfo::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadResponse.MoreInfo.url)
+  return _s;
+}
+inline const std::string& ClientDownloadResponse_MoreInfo::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void ClientDownloadResponse_MoreInfo::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadResponse_MoreInfo::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadResponse_MoreInfo::release_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadResponse.MoreInfo.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadResponse_MoreInfo::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadResponse.MoreInfo.url)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadResponse
+
+// optional .safe_browsing.ClientDownloadResponse.Verdict verdict = 1 [default = SAFE];
+inline bool ClientDownloadResponse::_internal_has_verdict() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientDownloadResponse::has_verdict() const {
+  return _internal_has_verdict();
+}
+inline void ClientDownloadResponse::clear_verdict() {
+  _impl_.verdict_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::safe_browsing::ClientDownloadResponse_Verdict ClientDownloadResponse::_internal_verdict() const {
+  return static_cast< ::safe_browsing::ClientDownloadResponse_Verdict >(_impl_.verdict_);
+}
+inline ::safe_browsing::ClientDownloadResponse_Verdict ClientDownloadResponse::verdict() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadResponse.verdict)
+  return _internal_verdict();
+}
+inline void ClientDownloadResponse::_internal_set_verdict(::safe_browsing::ClientDownloadResponse_Verdict value) {
+  assert(::safe_browsing::ClientDownloadResponse_Verdict_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.verdict_ = value;
+}
+inline void ClientDownloadResponse::set_verdict(::safe_browsing::ClientDownloadResponse_Verdict value) {
+  _internal_set_verdict(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadResponse.verdict)
+}
+
+// optional .safe_browsing.ClientDownloadResponse.MoreInfo more_info = 2;
+inline bool ClientDownloadResponse::_internal_has_more_info() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.more_info_ != nullptr);
+  return value;
+}
+inline bool ClientDownloadResponse::has_more_info() const {
+  return _internal_has_more_info();
+}
+inline void ClientDownloadResponse::clear_more_info() {
+  if (_impl_.more_info_ != nullptr) _impl_.more_info_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::safe_browsing::ClientDownloadResponse_MoreInfo& ClientDownloadResponse::_internal_more_info() const {
+  const ::safe_browsing::ClientDownloadResponse_MoreInfo* p = _impl_.more_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadResponse_MoreInfo&>(
+      ::safe_browsing::_ClientDownloadResponse_MoreInfo_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadResponse_MoreInfo& ClientDownloadResponse::more_info() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadResponse.more_info)
+  return _internal_more_info();
+}
+inline void ClientDownloadResponse::unsafe_arena_set_allocated_more_info(
+    ::safe_browsing::ClientDownloadResponse_MoreInfo* more_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.more_info_);
+  }
+  _impl_.more_info_ = more_info;
+  if (more_info) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientDownloadResponse.more_info)
+}
+inline ::safe_browsing::ClientDownloadResponse_MoreInfo* ClientDownloadResponse::release_more_info() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadResponse_MoreInfo* temp = _impl_.more_info_;
+  _impl_.more_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadResponse_MoreInfo* ClientDownloadResponse::unsafe_arena_release_more_info() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadResponse.more_info)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadResponse_MoreInfo* temp = _impl_.more_info_;
+  _impl_.more_info_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadResponse_MoreInfo* ClientDownloadResponse::_internal_mutable_more_info() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.more_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadResponse_MoreInfo>(GetArenaForAllocation());
+    _impl_.more_info_ = p;
+  }
+  return _impl_.more_info_;
+}
+inline ::safe_browsing::ClientDownloadResponse_MoreInfo* ClientDownloadResponse::mutable_more_info() {
+  ::safe_browsing::ClientDownloadResponse_MoreInfo* _msg = _internal_mutable_more_info();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadResponse.more_info)
+  return _msg;
+}
+inline void ClientDownloadResponse::set_allocated_more_info(::safe_browsing::ClientDownloadResponse_MoreInfo* more_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.more_info_;
+  }
+  if (more_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(more_info);
+    if (message_arena != submessage_arena) {
+      more_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, more_info, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.more_info_ = more_info;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadResponse.more_info)
+}
+
+// optional bytes token = 3;
+inline bool ClientDownloadResponse::_internal_has_token() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadResponse::has_token() const {
+  return _internal_has_token();
+}
+inline void ClientDownloadResponse::clear_token() {
+  _impl_.token_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadResponse::token() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadResponse.token)
+  return _internal_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadResponse::set_token(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.token_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadResponse.token)
+}
+inline std::string* ClientDownloadResponse::mutable_token() {
+  std::string* _s = _internal_mutable_token();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadResponse.token)
+  return _s;
+}
+inline const std::string& ClientDownloadResponse::_internal_token() const {
+  return _impl_.token_.Get();
+}
+inline void ClientDownloadResponse::_internal_set_token(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.token_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadResponse::_internal_mutable_token() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.token_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadResponse::release_token() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadResponse.token)
+  if (!_internal_has_token()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.token_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.token_.IsDefault()) {
+    _impl_.token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadResponse::set_allocated_token(std::string* token) {
+  if (token != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.token_.SetAllocated(token, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.token_.IsDefault()) {
+    _impl_.token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadResponse.token)
+}
+
+// optional bool upload = 5;
+inline bool ClientDownloadResponse::_internal_has_upload() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientDownloadResponse::has_upload() const {
+  return _internal_has_upload();
+}
+inline void ClientDownloadResponse::clear_upload() {
+  _impl_.upload_ = false;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline bool ClientDownloadResponse::_internal_upload() const {
+  return _impl_.upload_;
+}
+inline bool ClientDownloadResponse::upload() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadResponse.upload)
+  return _internal_upload();
+}
+inline void ClientDownloadResponse::_internal_set_upload(bool value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.upload_ = value;
+}
+inline void ClientDownloadResponse::set_upload(bool value) {
+  _internal_set_upload(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadResponse.upload)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadReport_UserInformation
+
+// optional string email = 1;
+inline bool ClientDownloadReport_UserInformation::_internal_has_email() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadReport_UserInformation::has_email() const {
+  return _internal_has_email();
+}
+inline void ClientDownloadReport_UserInformation::clear_email() {
+  _impl_.email_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadReport_UserInformation::email() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadReport.UserInformation.email)
+  return _internal_email();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadReport_UserInformation::set_email(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.email_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadReport.UserInformation.email)
+}
+inline std::string* ClientDownloadReport_UserInformation::mutable_email() {
+  std::string* _s = _internal_mutable_email();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.UserInformation.email)
+  return _s;
+}
+inline const std::string& ClientDownloadReport_UserInformation::_internal_email() const {
+  return _impl_.email_.Get();
+}
+inline void ClientDownloadReport_UserInformation::_internal_set_email(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.email_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadReport_UserInformation::_internal_mutable_email() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.email_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadReport_UserInformation::release_email() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadReport.UserInformation.email)
+  if (!_internal_has_email()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.email_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.email_.IsDefault()) {
+    _impl_.email_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadReport_UserInformation::set_allocated_email(std::string* email) {
+  if (email != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.email_.SetAllocated(email, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.email_.IsDefault()) {
+    _impl_.email_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadReport.UserInformation.email)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadReport
+
+// optional .safe_browsing.ClientDownloadReport.Reason reason = 1;
+inline bool ClientDownloadReport::_internal_has_reason() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientDownloadReport::has_reason() const {
+  return _internal_has_reason();
+}
+inline void ClientDownloadReport::clear_reason() {
+  _impl_.reason_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline ::safe_browsing::ClientDownloadReport_Reason ClientDownloadReport::_internal_reason() const {
+  return static_cast< ::safe_browsing::ClientDownloadReport_Reason >(_impl_.reason_);
+}
+inline ::safe_browsing::ClientDownloadReport_Reason ClientDownloadReport::reason() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadReport.reason)
+  return _internal_reason();
+}
+inline void ClientDownloadReport::_internal_set_reason(::safe_browsing::ClientDownloadReport_Reason value) {
+  assert(::safe_browsing::ClientDownloadReport_Reason_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.reason_ = value;
+}
+inline void ClientDownloadReport::set_reason(::safe_browsing::ClientDownloadReport_Reason value) {
+  _internal_set_reason(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadReport.reason)
+}
+
+// optional .safe_browsing.ClientDownloadRequest download_request = 2;
+inline bool ClientDownloadReport::_internal_has_download_request() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.download_request_ != nullptr);
+  return value;
+}
+inline bool ClientDownloadReport::has_download_request() const {
+  return _internal_has_download_request();
+}
+inline void ClientDownloadReport::clear_download_request() {
+  if (_impl_.download_request_ != nullptr) _impl_.download_request_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::safe_browsing::ClientDownloadRequest& ClientDownloadReport::_internal_download_request() const {
+  const ::safe_browsing::ClientDownloadRequest* p = _impl_.download_request_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest&>(
+      ::safe_browsing::_ClientDownloadRequest_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest& ClientDownloadReport::download_request() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadReport.download_request)
+  return _internal_download_request();
+}
+inline void ClientDownloadReport::unsafe_arena_set_allocated_download_request(
+    ::safe_browsing::ClientDownloadRequest* download_request) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.download_request_);
+  }
+  _impl_.download_request_ = download_request;
+  if (download_request) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientDownloadReport.download_request)
+}
+inline ::safe_browsing::ClientDownloadRequest* ClientDownloadReport::release_download_request() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadRequest* temp = _impl_.download_request_;
+  _impl_.download_request_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest* ClientDownloadReport::unsafe_arena_release_download_request() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadReport.download_request)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadRequest* temp = _impl_.download_request_;
+  _impl_.download_request_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest* ClientDownloadReport::_internal_mutable_download_request() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.download_request_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest>(GetArenaForAllocation());
+    _impl_.download_request_ = p;
+  }
+  return _impl_.download_request_;
+}
+inline ::safe_browsing::ClientDownloadRequest* ClientDownloadReport::mutable_download_request() {
+  ::safe_browsing::ClientDownloadRequest* _msg = _internal_mutable_download_request();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.download_request)
+  return _msg;
+}
+inline void ClientDownloadReport::set_allocated_download_request(::safe_browsing::ClientDownloadRequest* download_request) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.download_request_;
+  }
+  if (download_request) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(download_request);
+    if (message_arena != submessage_arena) {
+      download_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, download_request, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.download_request_ = download_request;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadReport.download_request)
+}
+
+// optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3;
+inline bool ClientDownloadReport::_internal_has_user_information() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.user_information_ != nullptr);
+  return value;
+}
+inline bool ClientDownloadReport::has_user_information() const {
+  return _internal_has_user_information();
+}
+inline void ClientDownloadReport::clear_user_information() {
+  if (_impl_.user_information_ != nullptr) _impl_.user_information_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::safe_browsing::ClientDownloadReport_UserInformation& ClientDownloadReport::_internal_user_information() const {
+  const ::safe_browsing::ClientDownloadReport_UserInformation* p = _impl_.user_information_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadReport_UserInformation&>(
+      ::safe_browsing::_ClientDownloadReport_UserInformation_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadReport_UserInformation& ClientDownloadReport::user_information() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadReport.user_information)
+  return _internal_user_information();
+}
+inline void ClientDownloadReport::unsafe_arena_set_allocated_user_information(
+    ::safe_browsing::ClientDownloadReport_UserInformation* user_information) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.user_information_);
+  }
+  _impl_.user_information_ = user_information;
+  if (user_information) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientDownloadReport.user_information)
+}
+inline ::safe_browsing::ClientDownloadReport_UserInformation* ClientDownloadReport::release_user_information() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientDownloadReport_UserInformation* temp = _impl_.user_information_;
+  _impl_.user_information_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadReport_UserInformation* ClientDownloadReport::unsafe_arena_release_user_information() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadReport.user_information)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientDownloadReport_UserInformation* temp = _impl_.user_information_;
+  _impl_.user_information_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadReport_UserInformation* ClientDownloadReport::_internal_mutable_user_information() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.user_information_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadReport_UserInformation>(GetArenaForAllocation());
+    _impl_.user_information_ = p;
+  }
+  return _impl_.user_information_;
+}
+inline ::safe_browsing::ClientDownloadReport_UserInformation* ClientDownloadReport::mutable_user_information() {
+  ::safe_browsing::ClientDownloadReport_UserInformation* _msg = _internal_mutable_user_information();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.user_information)
+  return _msg;
+}
+inline void ClientDownloadReport::set_allocated_user_information(::safe_browsing::ClientDownloadReport_UserInformation* user_information) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.user_information_;
+  }
+  if (user_information) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(user_information);
+    if (message_arena != submessage_arena) {
+      user_information = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, user_information, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.user_information_ = user_information;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadReport.user_information)
+}
+
+// optional bytes comment = 4;
+inline bool ClientDownloadReport::_internal_has_comment() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientDownloadReport::has_comment() const {
+  return _internal_has_comment();
+}
+inline void ClientDownloadReport::clear_comment() {
+  _impl_.comment_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientDownloadReport::comment() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadReport.comment)
+  return _internal_comment();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientDownloadReport::set_comment(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.comment_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadReport.comment)
+}
+inline std::string* ClientDownloadReport::mutable_comment() {
+  std::string* _s = _internal_mutable_comment();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.comment)
+  return _s;
+}
+inline const std::string& ClientDownloadReport::_internal_comment() const {
+  return _impl_.comment_.Get();
+}
+inline void ClientDownloadReport::_internal_set_comment(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.comment_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientDownloadReport::_internal_mutable_comment() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.comment_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientDownloadReport::release_comment() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadReport.comment)
+  if (!_internal_has_comment()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.comment_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.comment_.IsDefault()) {
+    _impl_.comment_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientDownloadReport::set_allocated_comment(std::string* comment) {
+  if (comment != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.comment_.SetAllocated(comment, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.comment_.IsDefault()) {
+    _impl_.comment_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadReport.comment)
+}
+
+// optional .safe_browsing.ClientDownloadResponse download_response = 5;
+inline bool ClientDownloadReport::_internal_has_download_response() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.download_response_ != nullptr);
+  return value;
+}
+inline bool ClientDownloadReport::has_download_response() const {
+  return _internal_has_download_response();
+}
+inline void ClientDownloadReport::clear_download_response() {
+  if (_impl_.download_response_ != nullptr) _impl_.download_response_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::safe_browsing::ClientDownloadResponse& ClientDownloadReport::_internal_download_response() const {
+  const ::safe_browsing::ClientDownloadResponse* p = _impl_.download_response_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadResponse&>(
+      ::safe_browsing::_ClientDownloadResponse_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadResponse& ClientDownloadReport::download_response() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadReport.download_response)
+  return _internal_download_response();
+}
+inline void ClientDownloadReport::unsafe_arena_set_allocated_download_response(
+    ::safe_browsing::ClientDownloadResponse* download_response) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.download_response_);
+  }
+  _impl_.download_response_ = download_response;
+  if (download_response) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientDownloadReport.download_response)
+}
+inline ::safe_browsing::ClientDownloadResponse* ClientDownloadReport::release_download_response() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::safe_browsing::ClientDownloadResponse* temp = _impl_.download_response_;
+  _impl_.download_response_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadResponse* ClientDownloadReport::unsafe_arena_release_download_response() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadReport.download_response)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::safe_browsing::ClientDownloadResponse* temp = _impl_.download_response_;
+  _impl_.download_response_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadResponse* ClientDownloadReport::_internal_mutable_download_response() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.download_response_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadResponse>(GetArenaForAllocation());
+    _impl_.download_response_ = p;
+  }
+  return _impl_.download_response_;
+}
+inline ::safe_browsing::ClientDownloadResponse* ClientDownloadReport::mutable_download_response() {
+  ::safe_browsing::ClientDownloadResponse* _msg = _internal_mutable_download_response();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.download_response)
+  return _msg;
+}
+inline void ClientDownloadReport::set_allocated_download_response(::safe_browsing::ClientDownloadResponse* download_response) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.download_response_;
+  }
+  if (download_response) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(download_response);
+    if (message_arena != submessage_arena) {
+      download_response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, download_response, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.download_response_ = download_response;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadReport.download_response)
+}
+
+// -------------------------------------------------------------------
+
+// ClientUploadResponse
+
+// optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1;
+inline bool ClientUploadResponse::_internal_has_status() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientUploadResponse::has_status() const {
+  return _internal_has_status();
+}
+inline void ClientUploadResponse::clear_status() {
+  _impl_.status_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline ::safe_browsing::ClientUploadResponse_UploadStatus ClientUploadResponse::_internal_status() const {
+  return static_cast< ::safe_browsing::ClientUploadResponse_UploadStatus >(_impl_.status_);
+}
+inline ::safe_browsing::ClientUploadResponse_UploadStatus ClientUploadResponse::status() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientUploadResponse.status)
+  return _internal_status();
+}
+inline void ClientUploadResponse::_internal_set_status(::safe_browsing::ClientUploadResponse_UploadStatus value) {
+  assert(::safe_browsing::ClientUploadResponse_UploadStatus_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.status_ = value;
+}
+inline void ClientUploadResponse::set_status(::safe_browsing::ClientUploadResponse_UploadStatus value) {
+  _internal_set_status(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientUploadResponse.status)
+}
+
+// optional string permalink = 2;
+inline bool ClientUploadResponse::_internal_has_permalink() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientUploadResponse::has_permalink() const {
+  return _internal_has_permalink();
+}
+inline void ClientUploadResponse::clear_permalink() {
+  _impl_.permalink_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientUploadResponse::permalink() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientUploadResponse.permalink)
+  return _internal_permalink();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientUploadResponse::set_permalink(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.permalink_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientUploadResponse.permalink)
+}
+inline std::string* ClientUploadResponse::mutable_permalink() {
+  std::string* _s = _internal_mutable_permalink();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientUploadResponse.permalink)
+  return _s;
+}
+inline const std::string& ClientUploadResponse::_internal_permalink() const {
+  return _impl_.permalink_.Get();
+}
+inline void ClientUploadResponse::_internal_set_permalink(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.permalink_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientUploadResponse::_internal_mutable_permalink() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.permalink_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientUploadResponse::release_permalink() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientUploadResponse.permalink)
+  if (!_internal_has_permalink()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.permalink_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.permalink_.IsDefault()) {
+    _impl_.permalink_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientUploadResponse::set_allocated_permalink(std::string* permalink) {
+  if (permalink != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.permalink_.SetAllocated(permalink, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.permalink_.IsDefault()) {
+    _impl_.permalink_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientUploadResponse.permalink)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_IncidentData_TrackedPreferenceIncident
+
+// optional string path = 1;
+inline bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_has_path() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident::has_path() const {
+  return _internal_has_path();
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::clear_path() {
+  _impl_.path_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident::path() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path)
+  return _internal_path();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_path(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.path_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path)
+}
+inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::mutable_path() {
+  std::string* _s = _internal_mutable_path();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_path() const {
+  return _impl_.path_.Get();
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_set_path(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.path_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_mutable_path() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.path_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::release_path() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path)
+  if (!_internal_has_path()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.path_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.path_.IsDefault()) {
+    _impl_.path_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_allocated_path(std::string* path) {
+  if (path != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.path_.SetAllocated(path, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.path_.IsDefault()) {
+    _impl_.path_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path)
+}
+
+// optional string atomic_value = 2;
+inline bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_has_atomic_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident::has_atomic_value() const {
+  return _internal_has_atomic_value();
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::clear_atomic_value() {
+  _impl_.atomic_value_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident::atomic_value() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value)
+  return _internal_atomic_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_atomic_value(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.atomic_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value)
+}
+inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::mutable_atomic_value() {
+  std::string* _s = _internal_mutable_atomic_value();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_atomic_value() const {
+  return _impl_.atomic_value_.Get();
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_set_atomic_value(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.atomic_value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_mutable_atomic_value() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.atomic_value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::release_atomic_value() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value)
+  if (!_internal_has_atomic_value()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.atomic_value_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.atomic_value_.IsDefault()) {
+    _impl_.atomic_value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_allocated_atomic_value(std::string* atomic_value) {
+  if (atomic_value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.atomic_value_.SetAllocated(atomic_value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.atomic_value_.IsDefault()) {
+    _impl_.atomic_value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value)
+}
+
+// repeated string split_key = 3;
+inline int ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_split_key_size() const {
+  return _impl_.split_key_.size();
+}
+inline int ClientIncidentReport_IncidentData_TrackedPreferenceIncident::split_key_size() const {
+  return _internal_split_key_size();
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::clear_split_key() {
+  _impl_.split_key_.Clear();
+}
+inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::add_split_key() {
+  std::string* _s = _internal_add_split_key();
+  // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_split_key(int index) const {
+  return _impl_.split_key_.Get(index);
+}
+inline const std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident::split_key(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key)
+  return _internal_split_key(index);
+}
+inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::mutable_split_key(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key)
+  return _impl_.split_key_.Mutable(index);
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_split_key(int index, const std::string& value) {
+  _impl_.split_key_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key)
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_split_key(int index, std::string&& value) {
+  _impl_.split_key_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key)
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_split_key(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.split_key_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key)
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_split_key(int index, const char* value, size_t size) {
+  _impl_.split_key_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key)
+}
+inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_add_split_key() {
+  return _impl_.split_key_.Add();
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::add_split_key(const std::string& value) {
+  _impl_.split_key_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key)
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::add_split_key(std::string&& value) {
+  _impl_.split_key_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key)
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::add_split_key(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.split_key_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key)
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::add_split_key(const char* value, size_t size) {
+  _impl_.split_key_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ClientIncidentReport_IncidentData_TrackedPreferenceIncident::split_key() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key)
+  return _impl_.split_key_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ClientIncidentReport_IncidentData_TrackedPreferenceIncident::mutable_split_key() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key)
+  return &_impl_.split_key_;
+}
+
+// optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.ValueState value_state = 4;
+inline bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_has_value_state() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident::has_value_state() const {
+  return _internal_has_value_state();
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::clear_value_state() {
+  _impl_.value_state_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_value_state() const {
+  return static_cast< ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState >(_impl_.value_state_);
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::value_state() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.value_state)
+  return _internal_value_state();
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_set_value_state(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState value) {
+  assert(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.value_state_ = value;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_value_state(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState value) {
+  _internal_set_value_state(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.value_state)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile
+
+// optional string relative_path = 1;
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_has_relative_path() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::has_relative_path() const {
+  return _internal_has_relative_path();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::clear_relative_path() {
+  _impl_.relative_path_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::relative_path() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.relative_path)
+  return _internal_relative_path();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_relative_path(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.relative_path_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.relative_path)
+}
+inline std::string* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::mutable_relative_path() {
+  std::string* _s = _internal_mutable_relative_path();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.relative_path)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_relative_path() const {
+  return _impl_.relative_path_.Get();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_set_relative_path(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.relative_path_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_mutable_relative_path() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.relative_path_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::release_relative_path() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.relative_path)
+  if (!_internal_has_relative_path()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.relative_path_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.relative_path_.IsDefault()) {
+    _impl_.relative_path_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_allocated_relative_path(std::string* relative_path) {
+  if (relative_path != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.relative_path_.SetAllocated(relative_path, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.relative_path_.IsDefault()) {
+    _impl_.relative_path_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.relative_path)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_has_signature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.signature_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::has_signature() const {
+  return _internal_has_signature();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::clear_signature() {
+  if (_impl_.signature_ != nullptr) _impl_.signature_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_signature() const {
+  const ::safe_browsing::ClientDownloadRequest_SignatureInfo* p = _impl_.signature_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest_SignatureInfo&>(
+      ::safe_browsing::_ClientDownloadRequest_SignatureInfo_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::signature() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.signature)
+  return _internal_signature();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::unsafe_arena_set_allocated_signature(
+    ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.signature_);
+  }
+  _impl_.signature_ = signature;
+  if (signature) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.signature)
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::release_signature() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = _impl_.signature_;
+  _impl_.signature_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::unsafe_arena_release_signature() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.signature)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = _impl_.signature_;
+  _impl_.signature_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_mutable_signature() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.signature_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_SignatureInfo>(GetArenaForAllocation());
+    _impl_.signature_ = p;
+  }
+  return _impl_.signature_;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::mutable_signature() {
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* _msg = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.signature)
+  return _msg;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.signature_;
+  }
+  if (signature) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(signature);
+    if (message_arena != submessage_arena) {
+      signature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, signature, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.signature_ = signature;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.signature)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_has_image_headers() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.image_headers_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::has_image_headers() const {
+  return _internal_has_image_headers();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::clear_image_headers() {
+  if (_impl_.image_headers_ != nullptr) _impl_.image_headers_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_image_headers() const {
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders* p = _impl_.image_headers_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest_ImageHeaders&>(
+      ::safe_browsing::_ClientDownloadRequest_ImageHeaders_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::image_headers() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.image_headers)
+  return _internal_image_headers();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::unsafe_arena_set_allocated_image_headers(
+    ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.image_headers_);
+  }
+  _impl_.image_headers_ = image_headers;
+  if (image_headers) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.image_headers)
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::release_image_headers() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = _impl_.image_headers_;
+  _impl_.image_headers_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::unsafe_arena_release_image_headers() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.image_headers)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = _impl_.image_headers_;
+  _impl_.image_headers_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_mutable_image_headers() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.image_headers_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_ImageHeaders>(GetArenaForAllocation());
+    _impl_.image_headers_ = p;
+  }
+  return _impl_.image_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::mutable_image_headers() {
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* _msg = _internal_mutable_image_headers();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.image_headers)
+  return _msg;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.image_headers_;
+  }
+  if (image_headers) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(image_headers);
+    if (message_arena != submessage_arena) {
+      image_headers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, image_headers, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.image_headers_ = image_headers;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.image_headers)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_IncidentData_BinaryIntegrityIncident
+
+// optional string file_basename = 1;
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_has_file_basename() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident::has_file_basename() const {
+  return _internal_has_file_basename();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_file_basename() {
+  _impl_.file_basename_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::file_basename() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.file_basename)
+  return _internal_file_basename();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_file_basename(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.file_basename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.file_basename)
+}
+inline std::string* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::mutable_file_basename() {
+  std::string* _s = _internal_mutable_file_basename();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.file_basename)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_file_basename() const {
+  return _impl_.file_basename_.Get();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_set_file_basename(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.file_basename_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_mutable_file_basename() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.file_basename_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::release_file_basename() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.file_basename)
+  if (!_internal_has_file_basename()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.file_basename_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.file_basename_.IsDefault()) {
+    _impl_.file_basename_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_allocated_file_basename(std::string* file_basename) {
+  if (file_basename != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.file_basename_.SetAllocated(file_basename, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.file_basename_.IsDefault()) {
+    _impl_.file_basename_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.file_basename)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_has_signature() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.signature_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident::has_signature() const {
+  return _internal_has_signature();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_signature() {
+  if (_impl_.signature_ != nullptr) _impl_.signature_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_signature() const {
+  const ::safe_browsing::ClientDownloadRequest_SignatureInfo* p = _impl_.signature_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest_SignatureInfo&>(
+      ::safe_browsing::_ClientDownloadRequest_SignatureInfo_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::signature() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.signature)
+  return _internal_signature();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::unsafe_arena_set_allocated_signature(
+    ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.signature_);
+  }
+  _impl_.signature_ = signature;
+  if (signature) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.signature)
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::release_signature() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = _impl_.signature_;
+  _impl_.signature_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::unsafe_arena_release_signature() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.signature)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = _impl_.signature_;
+  _impl_.signature_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_mutable_signature() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.signature_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_SignatureInfo>(GetArenaForAllocation());
+    _impl_.signature_ = p;
+  }
+  return _impl_.signature_;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::mutable_signature() {
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* _msg = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.signature)
+  return _msg;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.signature_;
+  }
+  if (signature) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(signature);
+    if (message_arena != submessage_arena) {
+      signature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, signature, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.signature_ = signature;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.signature)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_has_image_headers() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.image_headers_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident::has_image_headers() const {
+  return _internal_has_image_headers();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_image_headers() {
+  if (_impl_.image_headers_ != nullptr) _impl_.image_headers_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_image_headers() const {
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders* p = _impl_.image_headers_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest_ImageHeaders&>(
+      ::safe_browsing::_ClientDownloadRequest_ImageHeaders_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::image_headers() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.image_headers)
+  return _internal_image_headers();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::unsafe_arena_set_allocated_image_headers(
+    ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.image_headers_);
+  }
+  _impl_.image_headers_ = image_headers;
+  if (image_headers) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.image_headers)
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::release_image_headers() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = _impl_.image_headers_;
+  _impl_.image_headers_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::unsafe_arena_release_image_headers() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.image_headers)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = _impl_.image_headers_;
+  _impl_.image_headers_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_mutable_image_headers() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.image_headers_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_ImageHeaders>(GetArenaForAllocation());
+    _impl_.image_headers_ = p;
+  }
+  return _impl_.image_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::mutable_image_headers() {
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* _msg = _internal_mutable_image_headers();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.image_headers)
+  return _msg;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.image_headers_;
+  }
+  if (image_headers) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(image_headers);
+    if (message_arena != submessage_arena) {
+      image_headers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, image_headers, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.image_headers_ = image_headers;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.image_headers)
+}
+
+// optional int32 sec_error = 4;
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_has_sec_error() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident::has_sec_error() const {
+  return _internal_has_sec_error();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_sec_error() {
+  _impl_.sec_error_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int32_t ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_sec_error() const {
+  return _impl_.sec_error_;
+}
+inline int32_t ClientIncidentReport_IncidentData_BinaryIntegrityIncident::sec_error() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.sec_error)
+  return _internal_sec_error();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_set_sec_error(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.sec_error_ = value;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_sec_error(int32_t value) {
+  _internal_set_sec_error(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.sec_error)
+}
+
+// repeated .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile contained_file = 5;
+inline int ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_contained_file_size() const {
+  return _impl_.contained_file_.size();
+}
+inline int ClientIncidentReport_IncidentData_BinaryIntegrityIncident::contained_file_size() const {
+  return _internal_contained_file_size();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_contained_file() {
+  _impl_.contained_file_.Clear();
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::mutable_contained_file(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.contained_file)
+  return _impl_.contained_file_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile >*
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident::mutable_contained_file() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.contained_file)
+  return &_impl_.contained_file_;
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_contained_file(int index) const {
+  return _impl_.contained_file_.Get(index);
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::contained_file(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.contained_file)
+  return _internal_contained_file(index);
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_add_contained_file() {
+  return _impl_.contained_file_.Add();
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::add_contained_file() {
+  ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* _add = _internal_add_contained_file();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.contained_file)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile >&
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident::contained_file() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.contained_file)
+  return _impl_.contained_file_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_IncidentData_ResourceRequestIncident
+
+// optional bytes digest = 1;
+inline bool ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_has_digest() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData_ResourceRequestIncident::has_digest() const {
+  return _internal_has_digest();
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::clear_digest() {
+  _impl_.digest_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_IncidentData_ResourceRequestIncident::digest() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest)
+  return _internal_digest();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_digest(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.digest_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest)
+}
+inline std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::mutable_digest() {
+  std::string* _s = _internal_mutable_digest();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_digest() const {
+  return _impl_.digest_.Get();
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_set_digest(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.digest_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_mutable_digest() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.digest_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::release_digest() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest)
+  if (!_internal_has_digest()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.digest_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.digest_.IsDefault()) {
+    _impl_.digest_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_allocated_digest(std::string* digest) {
+  if (digest != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.digest_.SetAllocated(digest, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.digest_.IsDefault()) {
+    _impl_.digest_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest)
+}
+
+// optional string origin = 2;
+inline bool ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_has_origin() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData_ResourceRequestIncident::has_origin() const {
+  return _internal_has_origin();
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::clear_origin() {
+  _impl_.origin_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientIncidentReport_IncidentData_ResourceRequestIncident::origin() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin)
+  return _internal_origin();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_origin(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.origin_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin)
+}
+inline std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::mutable_origin() {
+  std::string* _s = _internal_mutable_origin();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_origin() const {
+  return _impl_.origin_.Get();
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_set_origin(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.origin_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_mutable_origin() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.origin_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::release_origin() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin)
+  if (!_internal_has_origin()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.origin_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.origin_.IsDefault()) {
+    _impl_.origin_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_allocated_origin(std::string* origin) {
+  if (origin != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.origin_.SetAllocated(origin, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.origin_.IsDefault()) {
+    _impl_.origin_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin)
+}
+
+// optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.Type type = 3 [default = UNKNOWN];
+inline bool ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_has_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData_ResourceRequestIncident::has_type() const {
+  return _internal_has_type();
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::clear_type() {
+  _impl_.type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_type() const {
+  return static_cast< ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type >(_impl_.type_);
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident::type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.type)
+  return _internal_type();
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_set_type(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type value) {
+  assert(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.type_ = value;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_type(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.type)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_IncidentData
+
+// optional int64 incident_time_msec = 1;
+inline bool ClientIncidentReport_IncidentData::_internal_has_incident_time_msec() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData::has_incident_time_msec() const {
+  return _internal_has_incident_time_msec();
+}
+inline void ClientIncidentReport_IncidentData::clear_incident_time_msec() {
+  _impl_.incident_time_msec_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int64_t ClientIncidentReport_IncidentData::_internal_incident_time_msec() const {
+  return _impl_.incident_time_msec_;
+}
+inline int64_t ClientIncidentReport_IncidentData::incident_time_msec() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.incident_time_msec)
+  return _internal_incident_time_msec();
+}
+inline void ClientIncidentReport_IncidentData::_internal_set_incident_time_msec(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.incident_time_msec_ = value;
+}
+inline void ClientIncidentReport_IncidentData::set_incident_time_msec(int64_t value) {
+  _internal_set_incident_time_msec(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.incident_time_msec)
+}
+
+// optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident tracked_preference = 2;
+inline bool ClientIncidentReport_IncidentData::_internal_has_tracked_preference() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.tracked_preference_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData::has_tracked_preference() const {
+  return _internal_has_tracked_preference();
+}
+inline void ClientIncidentReport_IncidentData::clear_tracked_preference() {
+  if (_impl_.tracked_preference_ != nullptr) _impl_.tracked_preference_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident& ClientIncidentReport_IncidentData::_internal_tracked_preference() const {
+  const ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* p = _impl_.tracked_preference_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident&>(
+      ::safe_browsing::_ClientIncidentReport_IncidentData_TrackedPreferenceIncident_default_instance_);
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident& ClientIncidentReport_IncidentData::tracked_preference() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.tracked_preference)
+  return _internal_tracked_preference();
+}
+inline void ClientIncidentReport_IncidentData::unsafe_arena_set_allocated_tracked_preference(
+    ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* tracked_preference) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tracked_preference_);
+  }
+  _impl_.tracked_preference_ = tracked_preference;
+  if (tracked_preference) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.tracked_preference)
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* ClientIncidentReport_IncidentData::release_tracked_preference() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* temp = _impl_.tracked_preference_;
+  _impl_.tracked_preference_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* ClientIncidentReport_IncidentData::unsafe_arena_release_tracked_preference() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.tracked_preference)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* temp = _impl_.tracked_preference_;
+  _impl_.tracked_preference_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* ClientIncidentReport_IncidentData::_internal_mutable_tracked_preference() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.tracked_preference_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident>(GetArenaForAllocation());
+    _impl_.tracked_preference_ = p;
+  }
+  return _impl_.tracked_preference_;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* ClientIncidentReport_IncidentData::mutable_tracked_preference() {
+  ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* _msg = _internal_mutable_tracked_preference();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.tracked_preference)
+  return _msg;
+}
+inline void ClientIncidentReport_IncidentData::set_allocated_tracked_preference(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* tracked_preference) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.tracked_preference_;
+  }
+  if (tracked_preference) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tracked_preference);
+    if (message_arena != submessage_arena) {
+      tracked_preference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, tracked_preference, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.tracked_preference_ = tracked_preference;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.tracked_preference)
+}
+
+// optional .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident binary_integrity = 3;
+inline bool ClientIncidentReport_IncidentData::_internal_has_binary_integrity() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.binary_integrity_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData::has_binary_integrity() const {
+  return _internal_has_binary_integrity();
+}
+inline void ClientIncidentReport_IncidentData::clear_binary_integrity() {
+  if (_impl_.binary_integrity_ != nullptr) _impl_.binary_integrity_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident& ClientIncidentReport_IncidentData::_internal_binary_integrity() const {
+  const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* p = _impl_.binary_integrity_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident&>(
+      ::safe_browsing::_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_default_instance_);
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident& ClientIncidentReport_IncidentData::binary_integrity() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.binary_integrity)
+  return _internal_binary_integrity();
+}
+inline void ClientIncidentReport_IncidentData::unsafe_arena_set_allocated_binary_integrity(
+    ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* binary_integrity) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.binary_integrity_);
+  }
+  _impl_.binary_integrity_ = binary_integrity;
+  if (binary_integrity) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.binary_integrity)
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* ClientIncidentReport_IncidentData::release_binary_integrity() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* temp = _impl_.binary_integrity_;
+  _impl_.binary_integrity_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* ClientIncidentReport_IncidentData::unsafe_arena_release_binary_integrity() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.binary_integrity)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* temp = _impl_.binary_integrity_;
+  _impl_.binary_integrity_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* ClientIncidentReport_IncidentData::_internal_mutable_binary_integrity() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.binary_integrity_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident>(GetArenaForAllocation());
+    _impl_.binary_integrity_ = p;
+  }
+  return _impl_.binary_integrity_;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* ClientIncidentReport_IncidentData::mutable_binary_integrity() {
+  ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* _msg = _internal_mutable_binary_integrity();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.binary_integrity)
+  return _msg;
+}
+inline void ClientIncidentReport_IncidentData::set_allocated_binary_integrity(::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* binary_integrity) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.binary_integrity_;
+  }
+  if (binary_integrity) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(binary_integrity);
+    if (message_arena != submessage_arena) {
+      binary_integrity = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, binary_integrity, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.binary_integrity_ = binary_integrity;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.binary_integrity)
+}
+
+// optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident resource_request = 7;
+inline bool ClientIncidentReport_IncidentData::_internal_has_resource_request() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.resource_request_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport_IncidentData::has_resource_request() const {
+  return _internal_has_resource_request();
+}
+inline void ClientIncidentReport_IncidentData::clear_resource_request() {
+  if (_impl_.resource_request_ != nullptr) _impl_.resource_request_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident& ClientIncidentReport_IncidentData::_internal_resource_request() const {
+  const ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* p = _impl_.resource_request_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident&>(
+      ::safe_browsing::_ClientIncidentReport_IncidentData_ResourceRequestIncident_default_instance_);
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident& ClientIncidentReport_IncidentData::resource_request() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.resource_request)
+  return _internal_resource_request();
+}
+inline void ClientIncidentReport_IncidentData::unsafe_arena_set_allocated_resource_request(
+    ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* resource_request) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.resource_request_);
+  }
+  _impl_.resource_request_ = resource_request;
+  if (resource_request) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.resource_request)
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* ClientIncidentReport_IncidentData::release_resource_request() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* temp = _impl_.resource_request_;
+  _impl_.resource_request_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* ClientIncidentReport_IncidentData::unsafe_arena_release_resource_request() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.resource_request)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* temp = _impl_.resource_request_;
+  _impl_.resource_request_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* ClientIncidentReport_IncidentData::_internal_mutable_resource_request() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.resource_request_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident>(GetArenaForAllocation());
+    _impl_.resource_request_ = p;
+  }
+  return _impl_.resource_request_;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* ClientIncidentReport_IncidentData::mutable_resource_request() {
+  ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* _msg = _internal_mutable_resource_request();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.resource_request)
+  return _msg;
+}
+inline void ClientIncidentReport_IncidentData::set_allocated_resource_request(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* resource_request) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.resource_request_;
+  }
+  if (resource_request) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(resource_request);
+    if (message_arena != submessage_arena) {
+      resource_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, resource_request, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.resource_request_ = resource_request;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.resource_request)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_DownloadDetails
+
+// optional bytes token = 1;
+inline bool ClientIncidentReport_DownloadDetails::_internal_has_token() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_DownloadDetails::has_token() const {
+  return _internal_has_token();
+}
+inline void ClientIncidentReport_DownloadDetails::clear_token() {
+  _impl_.token_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_DownloadDetails::token() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.DownloadDetails.token)
+  return _internal_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_DownloadDetails::set_token(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.token_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.DownloadDetails.token)
+}
+inline std::string* ClientIncidentReport_DownloadDetails::mutable_token() {
+  std::string* _s = _internal_mutable_token();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.DownloadDetails.token)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_DownloadDetails::_internal_token() const {
+  return _impl_.token_.Get();
+}
+inline void ClientIncidentReport_DownloadDetails::_internal_set_token(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.token_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_DownloadDetails::_internal_mutable_token() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.token_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_DownloadDetails::release_token() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.DownloadDetails.token)
+  if (!_internal_has_token()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.token_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.token_.IsDefault()) {
+    _impl_.token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_DownloadDetails::set_allocated_token(std::string* token) {
+  if (token != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.token_.SetAllocated(token, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.token_.IsDefault()) {
+    _impl_.token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.DownloadDetails.token)
+}
+
+// optional .safe_browsing.ClientDownloadRequest download = 2;
+inline bool ClientIncidentReport_DownloadDetails::_internal_has_download() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.download_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport_DownloadDetails::has_download() const {
+  return _internal_has_download();
+}
+inline void ClientIncidentReport_DownloadDetails::clear_download() {
+  if (_impl_.download_ != nullptr) _impl_.download_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::safe_browsing::ClientDownloadRequest& ClientIncidentReport_DownloadDetails::_internal_download() const {
+  const ::safe_browsing::ClientDownloadRequest* p = _impl_.download_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest&>(
+      ::safe_browsing::_ClientDownloadRequest_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest& ClientIncidentReport_DownloadDetails::download() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.DownloadDetails.download)
+  return _internal_download();
+}
+inline void ClientIncidentReport_DownloadDetails::unsafe_arena_set_allocated_download(
+    ::safe_browsing::ClientDownloadRequest* download) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.download_);
+  }
+  _impl_.download_ = download;
+  if (download) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.DownloadDetails.download)
+}
+inline ::safe_browsing::ClientDownloadRequest* ClientIncidentReport_DownloadDetails::release_download() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadRequest* temp = _impl_.download_;
+  _impl_.download_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest* ClientIncidentReport_DownloadDetails::unsafe_arena_release_download() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.DownloadDetails.download)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadRequest* temp = _impl_.download_;
+  _impl_.download_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest* ClientIncidentReport_DownloadDetails::_internal_mutable_download() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.download_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest>(GetArenaForAllocation());
+    _impl_.download_ = p;
+  }
+  return _impl_.download_;
+}
+inline ::safe_browsing::ClientDownloadRequest* ClientIncidentReport_DownloadDetails::mutable_download() {
+  ::safe_browsing::ClientDownloadRequest* _msg = _internal_mutable_download();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.DownloadDetails.download)
+  return _msg;
+}
+inline void ClientIncidentReport_DownloadDetails::set_allocated_download(::safe_browsing::ClientDownloadRequest* download) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.download_;
+  }
+  if (download) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(download);
+    if (message_arena != submessage_arena) {
+      download = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, download, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.download_ = download;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.DownloadDetails.download)
+}
+
+// optional int64 download_time_msec = 3;
+inline bool ClientIncidentReport_DownloadDetails::_internal_has_download_time_msec() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_DownloadDetails::has_download_time_msec() const {
+  return _internal_has_download_time_msec();
+}
+inline void ClientIncidentReport_DownloadDetails::clear_download_time_msec() {
+  _impl_.download_time_msec_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int64_t ClientIncidentReport_DownloadDetails::_internal_download_time_msec() const {
+  return _impl_.download_time_msec_;
+}
+inline int64_t ClientIncidentReport_DownloadDetails::download_time_msec() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.DownloadDetails.download_time_msec)
+  return _internal_download_time_msec();
+}
+inline void ClientIncidentReport_DownloadDetails::_internal_set_download_time_msec(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.download_time_msec_ = value;
+}
+inline void ClientIncidentReport_DownloadDetails::set_download_time_msec(int64_t value) {
+  _internal_set_download_time_msec(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.DownloadDetails.download_time_msec)
+}
+
+// optional int64 open_time_msec = 4;
+inline bool ClientIncidentReport_DownloadDetails::_internal_has_open_time_msec() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_DownloadDetails::has_open_time_msec() const {
+  return _internal_has_open_time_msec();
+}
+inline void ClientIncidentReport_DownloadDetails::clear_open_time_msec() {
+  _impl_.open_time_msec_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int64_t ClientIncidentReport_DownloadDetails::_internal_open_time_msec() const {
+  return _impl_.open_time_msec_;
+}
+inline int64_t ClientIncidentReport_DownloadDetails::open_time_msec() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.DownloadDetails.open_time_msec)
+  return _internal_open_time_msec();
+}
+inline void ClientIncidentReport_DownloadDetails::_internal_set_open_time_msec(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.open_time_msec_ = value;
+}
+inline void ClientIncidentReport_DownloadDetails::set_open_time_msec(int64_t value) {
+  _internal_set_open_time_msec(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.DownloadDetails.open_time_msec)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData_OS_RegistryValue
+
+// optional string name = 1;
+inline bool ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_OS_RegistryValue::has_name() const {
+  return _internal_has_name();
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_OS_RegistryValue::name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryValue::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryValue::release_name() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name)
+}
+
+// optional uint32 type = 2;
+inline bool ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_has_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_OS_RegistryValue::has_type() const {
+  return _internal_has_type();
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::clear_type() {
+  _impl_.type_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_type() const {
+  return _impl_.type_;
+}
+inline uint32_t ClientIncidentReport_EnvironmentData_OS_RegistryValue::type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.type)
+  return _internal_type();
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_set_type(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.type_ = value;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_type(uint32_t value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.type)
+}
+
+// optional bytes data = 3;
+inline bool ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_has_data() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_OS_RegistryValue::has_data() const {
+  return _internal_has_data();
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::clear_data() {
+  _impl_.data_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_OS_RegistryValue::data() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.data)
+  return _internal_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_data(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.data)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryValue::mutable_data() {
+  std::string* _s = _internal_mutable_data();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.data)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_data() const {
+  return _impl_.data_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_set_data(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.data_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_mutable_data() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.data_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryValue::release_data() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.data)
+  if (!_internal_has_data()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.data_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.data_.IsDefault()) {
+    _impl_.data_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_allocated_data(std::string* data) {
+  if (data != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.data_.IsDefault()) {
+    _impl_.data_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.data)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData_OS_RegistryKey
+
+// optional string name = 1;
+inline bool ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_OS_RegistryKey::has_name() const {
+  return _internal_has_name();
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_OS_RegistryKey::name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.name)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryKey::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.name)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryKey::release_name() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.name)
+}
+
+// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue value = 2;
+inline int ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_value_size() const {
+  return _impl_.value_.size();
+}
+inline int ClientIncidentReport_EnvironmentData_OS_RegistryKey::value_size() const {
+  return _internal_value_size();
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::clear_value() {
+  _impl_.value_.Clear();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue* ClientIncidentReport_EnvironmentData_OS_RegistryKey::mutable_value(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.value)
+  return _impl_.value_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue >*
+ClientIncidentReport_EnvironmentData_OS_RegistryKey::mutable_value() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.value)
+  return &_impl_.value_;
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue& ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_value(int index) const {
+  return _impl_.value_.Get(index);
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue& ClientIncidentReport_EnvironmentData_OS_RegistryKey::value(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.value)
+  return _internal_value(index);
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue* ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_add_value() {
+  return _impl_.value_.Add();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue* ClientIncidentReport_EnvironmentData_OS_RegistryKey::add_value() {
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue* _add = _internal_add_value();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.value)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue >&
+ClientIncidentReport_EnvironmentData_OS_RegistryKey::value() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.value)
+  return _impl_.value_;
+}
+
+// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey key = 3;
+inline int ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_key_size() const {
+  return _impl_.key_.size();
+}
+inline int ClientIncidentReport_EnvironmentData_OS_RegistryKey::key_size() const {
+  return _internal_key_size();
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::clear_key() {
+  _impl_.key_.Clear();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* ClientIncidentReport_EnvironmentData_OS_RegistryKey::mutable_key(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.key)
+  return _impl_.key_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >*
+ClientIncidentReport_EnvironmentData_OS_RegistryKey::mutable_key() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.key)
+  return &_impl_.key_;
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey& ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_key(int index) const {
+  return _impl_.key_.Get(index);
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey& ClientIncidentReport_EnvironmentData_OS_RegistryKey::key(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.key)
+  return _internal_key(index);
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_add_key() {
+  return _impl_.key_.Add();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* ClientIncidentReport_EnvironmentData_OS_RegistryKey::add_key() {
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* _add = _internal_add_key();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.key)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >&
+ClientIncidentReport_EnvironmentData_OS_RegistryKey::key() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.key)
+  return _impl_.key_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData_OS
+
+// optional string os_name = 1;
+inline bool ClientIncidentReport_EnvironmentData_OS::_internal_has_os_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_OS::has_os_name() const {
+  return _internal_has_os_name();
+}
+inline void ClientIncidentReport_EnvironmentData_OS::clear_os_name() {
+  _impl_.os_name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_OS::os_name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name)
+  return _internal_os_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_OS::set_os_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.os_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS::mutable_os_name() {
+  std::string* _s = _internal_mutable_os_name();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_OS::_internal_os_name() const {
+  return _impl_.os_name_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_OS::_internal_set_os_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.os_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS::_internal_mutable_os_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.os_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS::release_os_name() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name)
+  if (!_internal_has_os_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.os_name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.os_name_.IsDefault()) {
+    _impl_.os_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::set_allocated_os_name(std::string* os_name) {
+  if (os_name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.os_name_.SetAllocated(os_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.os_name_.IsDefault()) {
+    _impl_.os_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name)
+}
+
+// optional string os_version = 2;
+inline bool ClientIncidentReport_EnvironmentData_OS::_internal_has_os_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_OS::has_os_version() const {
+  return _internal_has_os_version();
+}
+inline void ClientIncidentReport_EnvironmentData_OS::clear_os_version() {
+  _impl_.os_version_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_OS::os_version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_version)
+  return _internal_os_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_OS::set_os_version(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.os_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_version)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS::mutable_os_version() {
+  std::string* _s = _internal_mutable_os_version();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_version)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_OS::_internal_os_version() const {
+  return _impl_.os_version_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_OS::_internal_set_os_version(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.os_version_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS::_internal_mutable_os_version() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.os_version_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_OS::release_os_version() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_version)
+  if (!_internal_has_os_version()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.os_version_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.os_version_.IsDefault()) {
+    _impl_.os_version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::set_allocated_os_version(std::string* os_version) {
+  if (os_version != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.os_version_.SetAllocated(os_version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.os_version_.IsDefault()) {
+    _impl_.os_version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_version)
+}
+
+// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey registry_key = 3;
+inline int ClientIncidentReport_EnvironmentData_OS::_internal_registry_key_size() const {
+  return _impl_.registry_key_.size();
+}
+inline int ClientIncidentReport_EnvironmentData_OS::registry_key_size() const {
+  return _internal_registry_key_size();
+}
+inline void ClientIncidentReport_EnvironmentData_OS::clear_registry_key() {
+  _impl_.registry_key_.Clear();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* ClientIncidentReport_EnvironmentData_OS::mutable_registry_key(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.registry_key)
+  return _impl_.registry_key_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >*
+ClientIncidentReport_EnvironmentData_OS::mutable_registry_key() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.EnvironmentData.OS.registry_key)
+  return &_impl_.registry_key_;
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey& ClientIncidentReport_EnvironmentData_OS::_internal_registry_key(int index) const {
+  return _impl_.registry_key_.Get(index);
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey& ClientIncidentReport_EnvironmentData_OS::registry_key(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.registry_key)
+  return _internal_registry_key(index);
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* ClientIncidentReport_EnvironmentData_OS::_internal_add_registry_key() {
+  return _impl_.registry_key_.Add();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* ClientIncidentReport_EnvironmentData_OS::add_registry_key() {
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* _add = _internal_add_registry_key();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.OS.registry_key)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >&
+ClientIncidentReport_EnvironmentData_OS::registry_key() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.EnvironmentData.OS.registry_key)
+  return _impl_.registry_key_;
+}
+
+// optional bool is_enrolled_to_domain = 4;
+inline bool ClientIncidentReport_EnvironmentData_OS::_internal_has_is_enrolled_to_domain() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_OS::has_is_enrolled_to_domain() const {
+  return _internal_has_is_enrolled_to_domain();
+}
+inline void ClientIncidentReport_EnvironmentData_OS::clear_is_enrolled_to_domain() {
+  _impl_.is_enrolled_to_domain_ = false;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline bool ClientIncidentReport_EnvironmentData_OS::_internal_is_enrolled_to_domain() const {
+  return _impl_.is_enrolled_to_domain_;
+}
+inline bool ClientIncidentReport_EnvironmentData_OS::is_enrolled_to_domain() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.is_enrolled_to_domain)
+  return _internal_is_enrolled_to_domain();
+}
+inline void ClientIncidentReport_EnvironmentData_OS::_internal_set_is_enrolled_to_domain(bool value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.is_enrolled_to_domain_ = value;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::set_is_enrolled_to_domain(bool value) {
+  _internal_set_is_enrolled_to_domain(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.is_enrolled_to_domain)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData_Machine
+
+// optional string cpu_architecture = 1;
+inline bool ClientIncidentReport_EnvironmentData_Machine::_internal_has_cpu_architecture() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Machine::has_cpu_architecture() const {
+  return _internal_has_cpu_architecture();
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::clear_cpu_architecture() {
+  _impl_.cpu_architecture_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Machine::cpu_architecture() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture)
+  return _internal_cpu_architecture();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_Machine::set_cpu_architecture(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.cpu_architecture_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Machine::mutable_cpu_architecture() {
+  std::string* _s = _internal_mutable_cpu_architecture();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Machine::_internal_cpu_architecture() const {
+  return _impl_.cpu_architecture_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::_internal_set_cpu_architecture(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.cpu_architecture_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Machine::_internal_mutable_cpu_architecture() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.cpu_architecture_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Machine::release_cpu_architecture() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture)
+  if (!_internal_has_cpu_architecture()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.cpu_architecture_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.cpu_architecture_.IsDefault()) {
+    _impl_.cpu_architecture_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::set_allocated_cpu_architecture(std::string* cpu_architecture) {
+  if (cpu_architecture != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.cpu_architecture_.SetAllocated(cpu_architecture, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.cpu_architecture_.IsDefault()) {
+    _impl_.cpu_architecture_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture)
+}
+
+// optional string cpu_vendor = 2;
+inline bool ClientIncidentReport_EnvironmentData_Machine::_internal_has_cpu_vendor() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Machine::has_cpu_vendor() const {
+  return _internal_has_cpu_vendor();
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::clear_cpu_vendor() {
+  _impl_.cpu_vendor_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Machine::cpu_vendor() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor)
+  return _internal_cpu_vendor();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_Machine::set_cpu_vendor(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.cpu_vendor_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Machine::mutable_cpu_vendor() {
+  std::string* _s = _internal_mutable_cpu_vendor();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Machine::_internal_cpu_vendor() const {
+  return _impl_.cpu_vendor_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::_internal_set_cpu_vendor(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.cpu_vendor_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Machine::_internal_mutable_cpu_vendor() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.cpu_vendor_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Machine::release_cpu_vendor() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor)
+  if (!_internal_has_cpu_vendor()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.cpu_vendor_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.cpu_vendor_.IsDefault()) {
+    _impl_.cpu_vendor_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::set_allocated_cpu_vendor(std::string* cpu_vendor) {
+  if (cpu_vendor != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.cpu_vendor_.SetAllocated(cpu_vendor, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.cpu_vendor_.IsDefault()) {
+    _impl_.cpu_vendor_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor)
+}
+
+// optional uint32 cpuid = 3;
+inline bool ClientIncidentReport_EnvironmentData_Machine::_internal_has_cpuid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Machine::has_cpuid() const {
+  return _internal_has_cpuid();
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::clear_cpuid() {
+  _impl_.cpuid_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t ClientIncidentReport_EnvironmentData_Machine::_internal_cpuid() const {
+  return _impl_.cpuid_;
+}
+inline uint32_t ClientIncidentReport_EnvironmentData_Machine::cpuid() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpuid)
+  return _internal_cpuid();
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::_internal_set_cpuid(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.cpuid_ = value;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::set_cpuid(uint32_t value) {
+  _internal_set_cpuid(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpuid)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData_Process_Patch
+
+// optional string function = 1;
+inline bool ClientIncidentReport_EnvironmentData_Process_Patch::_internal_has_function() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process_Patch::has_function() const {
+  return _internal_has_function();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::clear_function() {
+  _impl_.function_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_Patch::function() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function)
+  return _internal_function();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_Process_Patch::set_function(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.function_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_Patch::mutable_function() {
+  std::string* _s = _internal_mutable_function();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_Patch::_internal_function() const {
+  return _impl_.function_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::_internal_set_function(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.function_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_Patch::_internal_mutable_function() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.function_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_Patch::release_function() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function)
+  if (!_internal_has_function()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.function_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.function_.IsDefault()) {
+    _impl_.function_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_allocated_function(std::string* function) {
+  if (function != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.function_.SetAllocated(function, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.function_.IsDefault()) {
+    _impl_.function_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function)
+}
+
+// optional string target_dll = 2;
+inline bool ClientIncidentReport_EnvironmentData_Process_Patch::_internal_has_target_dll() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process_Patch::has_target_dll() const {
+  return _internal_has_target_dll();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::clear_target_dll() {
+  _impl_.target_dll_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_Patch::target_dll() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.target_dll)
+  return _internal_target_dll();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_Process_Patch::set_target_dll(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.target_dll_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.target_dll)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_Patch::mutable_target_dll() {
+  std::string* _s = _internal_mutable_target_dll();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.target_dll)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_Patch::_internal_target_dll() const {
+  return _impl_.target_dll_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::_internal_set_target_dll(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.target_dll_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_Patch::_internal_mutable_target_dll() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.target_dll_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_Patch::release_target_dll() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.target_dll)
+  if (!_internal_has_target_dll()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.target_dll_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.target_dll_.IsDefault()) {
+    _impl_.target_dll_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_allocated_target_dll(std::string* target_dll) {
+  if (target_dll != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.target_dll_.SetAllocated(target_dll, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.target_dll_.IsDefault()) {
+    _impl_.target_dll_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.target_dll)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData_Process_NetworkProvider
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData_Process_Dll
+
+// optional string path = 1;
+inline bool ClientIncidentReport_EnvironmentData_Process_Dll::_internal_has_path() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process_Dll::has_path() const {
+  return _internal_has_path();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_path() {
+  _impl_.path_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_Dll::path() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path)
+  return _internal_path();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_Process_Dll::set_path(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.path_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_Dll::mutable_path() {
+  std::string* _s = _internal_mutable_path();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_Dll::_internal_path() const {
+  return _impl_.path_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::_internal_set_path(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.path_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_Dll::_internal_mutable_path() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.path_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_Dll::release_path() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path)
+  if (!_internal_has_path()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.path_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.path_.IsDefault()) {
+    _impl_.path_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_allocated_path(std::string* path) {
+  if (path != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.path_.SetAllocated(path, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.path_.IsDefault()) {
+    _impl_.path_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path)
+}
+
+// optional uint64 base_address = 2;
+inline bool ClientIncidentReport_EnvironmentData_Process_Dll::_internal_has_base_address() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process_Dll::has_base_address() const {
+  return _internal_has_base_address();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_base_address() {
+  _impl_.base_address_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint64_t ClientIncidentReport_EnvironmentData_Process_Dll::_internal_base_address() const {
+  return _impl_.base_address_;
+}
+inline uint64_t ClientIncidentReport_EnvironmentData_Process_Dll::base_address() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.base_address)
+  return _internal_base_address();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::_internal_set_base_address(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.base_address_ = value;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_base_address(uint64_t value) {
+  _internal_set_base_address(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.base_address)
+}
+
+// optional uint32 length = 3;
+inline bool ClientIncidentReport_EnvironmentData_Process_Dll::_internal_has_length() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process_Dll::has_length() const {
+  return _internal_has_length();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_length() {
+  _impl_.length_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint32_t ClientIncidentReport_EnvironmentData_Process_Dll::_internal_length() const {
+  return _impl_.length_;
+}
+inline uint32_t ClientIncidentReport_EnvironmentData_Process_Dll::length() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.length)
+  return _internal_length();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::_internal_set_length(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.length_ = value;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_length(uint32_t value) {
+  _internal_set_length(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.length)
+}
+
+// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.Feature feature = 4;
+inline int ClientIncidentReport_EnvironmentData_Process_Dll::_internal_feature_size() const {
+  return _impl_.feature_.size();
+}
+inline int ClientIncidentReport_EnvironmentData_Process_Dll::feature_size() const {
+  return _internal_feature_size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_feature() {
+  _impl_.feature_.Clear();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll::_internal_feature(int index) const {
+  return static_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature >(_impl_.feature_.Get(index));
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll::feature(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.feature)
+  return _internal_feature(index);
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_feature(int index, ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature value) {
+  assert(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature_IsValid(value));
+  _impl_.feature_.Set(index, value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.feature)
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::_internal_add_feature(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature value) {
+  assert(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature_IsValid(value));
+  _impl_.feature_.Add(value);
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::add_feature(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature value) {
+  _internal_add_feature(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.feature)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+ClientIncidentReport_EnvironmentData_Process_Dll::feature() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.feature)
+  return _impl_.feature_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+ClientIncidentReport_EnvironmentData_Process_Dll::_internal_mutable_feature() {
+  return &_impl_.feature_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+ClientIncidentReport_EnvironmentData_Process_Dll::mutable_feature() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.feature)
+  return _internal_mutable_feature();
+}
+
+// optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+inline bool ClientIncidentReport_EnvironmentData_Process_Dll::_internal_has_image_headers() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.image_headers_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process_Dll::has_image_headers() const {
+  return _internal_has_image_headers();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_image_headers() {
+  if (_impl_.image_headers_ != nullptr) _impl_.image_headers_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientIncidentReport_EnvironmentData_Process_Dll::_internal_image_headers() const {
+  const ::safe_browsing::ClientDownloadRequest_ImageHeaders* p = _impl_.image_headers_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientDownloadRequest_ImageHeaders&>(
+      ::safe_browsing::_ClientDownloadRequest_ImageHeaders_default_instance_);
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientIncidentReport_EnvironmentData_Process_Dll::image_headers() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.image_headers)
+  return _internal_image_headers();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::unsafe_arena_set_allocated_image_headers(
+    ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.image_headers_);
+  }
+  _impl_.image_headers_ = image_headers;
+  if (image_headers) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.image_headers)
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_EnvironmentData_Process_Dll::release_image_headers() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = _impl_.image_headers_;
+  _impl_.image_headers_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_EnvironmentData_Process_Dll::unsafe_arena_release_image_headers() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.image_headers)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = _impl_.image_headers_;
+  _impl_.image_headers_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_EnvironmentData_Process_Dll::_internal_mutable_image_headers() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.image_headers_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_ImageHeaders>(GetArenaForAllocation());
+    _impl_.image_headers_ = p;
+  }
+  return _impl_.image_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_EnvironmentData_Process_Dll::mutable_image_headers() {
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* _msg = _internal_mutable_image_headers();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.image_headers)
+  return _msg;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.image_headers_;
+  }
+  if (image_headers) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(image_headers);
+    if (message_arena != submessage_arena) {
+      image_headers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, image_headers, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.image_headers_ = image_headers;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.image_headers)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification
+
+// optional uint32 file_offset = 1;
+inline bool ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_has_file_offset() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::has_file_offset() const {
+  return _internal_has_file_offset();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::clear_file_offset() {
+  _impl_.file_offset_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline uint32_t ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_file_offset() const {
+  return _impl_.file_offset_;
+}
+inline uint32_t ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::file_offset() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.file_offset)
+  return _internal_file_offset();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_set_file_offset(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.file_offset_ = value;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_file_offset(uint32_t value) {
+  _internal_set_file_offset(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.file_offset)
+}
+
+// optional int32 byte_count = 2;
+inline bool ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_has_byte_count() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::has_byte_count() const {
+  return _internal_has_byte_count();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::clear_byte_count() {
+  _impl_.byte_count_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int32_t ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_byte_count() const {
+  return _impl_.byte_count_;
+}
+inline int32_t ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::byte_count() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.byte_count)
+  return _internal_byte_count();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_set_byte_count(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.byte_count_ = value;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_byte_count(int32_t value) {
+  _internal_set_byte_count(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.byte_count)
+}
+
+// optional bytes modified_bytes = 3;
+inline bool ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_has_modified_bytes() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::has_modified_bytes() const {
+  return _internal_has_modified_bytes();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::clear_modified_bytes() {
+  _impl_.modified_bytes_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::modified_bytes() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.modified_bytes)
+  return _internal_modified_bytes();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_modified_bytes(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.modified_bytes_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.modified_bytes)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::mutable_modified_bytes() {
+  std::string* _s = _internal_mutable_modified_bytes();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.modified_bytes)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_modified_bytes() const {
+  return _impl_.modified_bytes_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_set_modified_bytes(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.modified_bytes_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_mutable_modified_bytes() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.modified_bytes_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::release_modified_bytes() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.modified_bytes)
+  if (!_internal_has_modified_bytes()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.modified_bytes_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.modified_bytes_.IsDefault()) {
+    _impl_.modified_bytes_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_allocated_modified_bytes(std::string* modified_bytes) {
+  if (modified_bytes != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.modified_bytes_.SetAllocated(modified_bytes, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.modified_bytes_.IsDefault()) {
+    _impl_.modified_bytes_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.modified_bytes)
+}
+
+// optional string export_name = 4;
+inline bool ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_has_export_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::has_export_name() const {
+  return _internal_has_export_name();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::clear_export_name() {
+  _impl_.export_name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::export_name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.export_name)
+  return _internal_export_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_export_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.export_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.export_name)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::mutable_export_name() {
+  std::string* _s = _internal_mutable_export_name();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.export_name)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_export_name() const {
+  return _impl_.export_name_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_set_export_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.export_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_mutable_export_name() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.export_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::release_export_name() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.export_name)
+  if (!_internal_has_export_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.export_name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.export_name_.IsDefault()) {
+    _impl_.export_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_allocated_export_name(std::string* export_name) {
+  if (export_name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.export_name_.SetAllocated(export_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.export_name_.IsDefault()) {
+    _impl_.export_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.export_name)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData_Process_ModuleState
+
+// optional string name = 1;
+inline bool ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process_ModuleState::has_name() const {
+  return _internal_has_name();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState::name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.name)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.name)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState::release_name() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.name)
+}
+
+// optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.ModifiedState modified_state = 2;
+inline bool ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_has_modified_state() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process_ModuleState::has_modified_state() const {
+  return _internal_has_modified_state();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::clear_modified_state() {
+  _impl_.modified_state_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_modified_state() const {
+  return static_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState >(_impl_.modified_state_);
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::modified_state() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.modified_state)
+  return _internal_modified_state();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_set_modified_state(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState value) {
+  assert(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.modified_state_ = value;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_modified_state(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState value) {
+  _internal_set_modified_state(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.modified_state)
+}
+
+// repeated string OBSOLETE_modified_export = 3;
+inline int ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_obsolete_modified_export_size() const {
+  return _impl_.obsolete_modified_export_.size();
+}
+inline int ClientIncidentReport_EnvironmentData_Process_ModuleState::obsolete_modified_export_size() const {
+  return _internal_obsolete_modified_export_size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::clear_obsolete_modified_export() {
+  _impl_.obsolete_modified_export_.Clear();
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState::add_obsolete_modified_export() {
+  std::string* _s = _internal_add_obsolete_modified_export();
+  // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_obsolete_modified_export(int index) const {
+  return _impl_.obsolete_modified_export_.Get(index);
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState::obsolete_modified_export(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export)
+  return _internal_obsolete_modified_export(index);
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState::mutable_obsolete_modified_export(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export)
+  return _impl_.obsolete_modified_export_.Mutable(index);
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_obsolete_modified_export(int index, const std::string& value) {
+  _impl_.obsolete_modified_export_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export)
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_obsolete_modified_export(int index, std::string&& value) {
+  _impl_.obsolete_modified_export_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export)
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_obsolete_modified_export(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.obsolete_modified_export_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export)
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_obsolete_modified_export(int index, const char* value, size_t size) {
+  _impl_.obsolete_modified_export_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_add_obsolete_modified_export() {
+  return _impl_.obsolete_modified_export_.Add();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::add_obsolete_modified_export(const std::string& value) {
+  _impl_.obsolete_modified_export_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export)
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::add_obsolete_modified_export(std::string&& value) {
+  _impl_.obsolete_modified_export_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export)
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::add_obsolete_modified_export(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.obsolete_modified_export_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export)
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::add_obsolete_modified_export(const char* value, size_t size) {
+  _impl_.obsolete_modified_export_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ClientIncidentReport_EnvironmentData_Process_ModuleState::obsolete_modified_export() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export)
+  return _impl_.obsolete_modified_export_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ClientIncidentReport_EnvironmentData_Process_ModuleState::mutable_obsolete_modified_export() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export)
+  return &_impl_.obsolete_modified_export_;
+}
+
+// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification modification = 4;
+inline int ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_modification_size() const {
+  return _impl_.modification_.size();
+}
+inline int ClientIncidentReport_EnvironmentData_Process_ModuleState::modification_size() const {
+  return _internal_modification_size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::clear_modification() {
+  _impl_.modification_.Clear();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* ClientIncidentReport_EnvironmentData_Process_ModuleState::mutable_modification(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.modification)
+  return _impl_.modification_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification >*
+ClientIncidentReport_EnvironmentData_Process_ModuleState::mutable_modification() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.modification)
+  return &_impl_.modification_;
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_modification(int index) const {
+  return _impl_.modification_.Get(index);
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& ClientIncidentReport_EnvironmentData_Process_ModuleState::modification(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.modification)
+  return _internal_modification(index);
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_add_modification() {
+  return _impl_.modification_.Add();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* ClientIncidentReport_EnvironmentData_Process_ModuleState::add_modification() {
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* _add = _internal_add_modification();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.modification)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification >&
+ClientIncidentReport_EnvironmentData_Process_ModuleState::modification() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.modification)
+  return _impl_.modification_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData_Process
+
+// optional string version = 1;
+inline bool ClientIncidentReport_EnvironmentData_Process::_internal_has_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::has_version() const {
+  return _internal_has_version();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_version() {
+  _impl_.version_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process::version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version)
+  return _internal_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_EnvironmentData_Process::set_version(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process::mutable_version() {
+  std::string* _s = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process::_internal_version() const {
+  return _impl_.version_.Get();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::_internal_set_version(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.version_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process::_internal_mutable_version() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.version_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process::release_version() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version)
+  if (!_internal_has_version()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.version_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_.IsDefault()) {
+    _impl_.version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_allocated_version(std::string* version) {
+  if (version != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_.IsDefault()) {
+    _impl_.version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version)
+}
+
+// repeated string OBSOLETE_dlls = 2;
+inline int ClientIncidentReport_EnvironmentData_Process::_internal_obsolete_dlls_size() const {
+  return _impl_.obsolete_dlls_.size();
+}
+inline int ClientIncidentReport_EnvironmentData_Process::obsolete_dlls_size() const {
+  return _internal_obsolete_dlls_size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_obsolete_dlls() {
+  _impl_.obsolete_dlls_.Clear();
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process::add_obsolete_dlls() {
+  std::string* _s = _internal_add_obsolete_dlls();
+  // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process::_internal_obsolete_dlls(int index) const {
+  return _impl_.obsolete_dlls_.Get(index);
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process::obsolete_dlls(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls)
+  return _internal_obsolete_dlls(index);
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process::mutable_obsolete_dlls(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls)
+  return _impl_.obsolete_dlls_.Mutable(index);
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_obsolete_dlls(int index, const std::string& value) {
+  _impl_.obsolete_dlls_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls)
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_obsolete_dlls(int index, std::string&& value) {
+  _impl_.obsolete_dlls_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls)
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_obsolete_dlls(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.obsolete_dlls_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls)
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_obsolete_dlls(int index, const char* value, size_t size) {
+  _impl_.obsolete_dlls_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process::_internal_add_obsolete_dlls() {
+  return _impl_.obsolete_dlls_.Add();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::add_obsolete_dlls(const std::string& value) {
+  _impl_.obsolete_dlls_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls)
+}
+inline void ClientIncidentReport_EnvironmentData_Process::add_obsolete_dlls(std::string&& value) {
+  _impl_.obsolete_dlls_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls)
+}
+inline void ClientIncidentReport_EnvironmentData_Process::add_obsolete_dlls(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.obsolete_dlls_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls)
+}
+inline void ClientIncidentReport_EnvironmentData_Process::add_obsolete_dlls(const char* value, size_t size) {
+  _impl_.obsolete_dlls_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ClientIncidentReport_EnvironmentData_Process::obsolete_dlls() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls)
+  return _impl_.obsolete_dlls_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ClientIncidentReport_EnvironmentData_Process::mutable_obsolete_dlls() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls)
+  return &_impl_.obsolete_dlls_;
+}
+
+// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch patches = 3;
+inline int ClientIncidentReport_EnvironmentData_Process::_internal_patches_size() const {
+  return _impl_.patches_.size();
+}
+inline int ClientIncidentReport_EnvironmentData_Process::patches_size() const {
+  return _internal_patches_size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_patches() {
+  _impl_.patches_.Clear();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch* ClientIncidentReport_EnvironmentData_Process::mutable_patches(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.patches)
+  return _impl_.patches_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch >*
+ClientIncidentReport_EnvironmentData_Process::mutable_patches() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.patches)
+  return &_impl_.patches_;
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch& ClientIncidentReport_EnvironmentData_Process::_internal_patches(int index) const {
+  return _impl_.patches_.Get(index);
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch& ClientIncidentReport_EnvironmentData_Process::patches(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.patches)
+  return _internal_patches(index);
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch* ClientIncidentReport_EnvironmentData_Process::_internal_add_patches() {
+  return _impl_.patches_.Add();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch* ClientIncidentReport_EnvironmentData_Process::add_patches() {
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch* _add = _internal_add_patches();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.patches)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch >&
+ClientIncidentReport_EnvironmentData_Process::patches() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.patches)
+  return _impl_.patches_;
+}
+
+// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider network_providers = 4;
+inline int ClientIncidentReport_EnvironmentData_Process::_internal_network_providers_size() const {
+  return _impl_.network_providers_.size();
+}
+inline int ClientIncidentReport_EnvironmentData_Process::network_providers_size() const {
+  return _internal_network_providers_size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_network_providers() {
+  _impl_.network_providers_.Clear();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider* ClientIncidentReport_EnvironmentData_Process::mutable_network_providers(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.network_providers)
+  return _impl_.network_providers_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider >*
+ClientIncidentReport_EnvironmentData_Process::mutable_network_providers() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.network_providers)
+  return &_impl_.network_providers_;
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider& ClientIncidentReport_EnvironmentData_Process::_internal_network_providers(int index) const {
+  return _impl_.network_providers_.Get(index);
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider& ClientIncidentReport_EnvironmentData_Process::network_providers(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.network_providers)
+  return _internal_network_providers(index);
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider* ClientIncidentReport_EnvironmentData_Process::_internal_add_network_providers() {
+  return _impl_.network_providers_.Add();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider* ClientIncidentReport_EnvironmentData_Process::add_network_providers() {
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider* _add = _internal_add_network_providers();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.network_providers)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider >&
+ClientIncidentReport_EnvironmentData_Process::network_providers() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.network_providers)
+  return _impl_.network_providers_;
+}
+
+// optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Channel chrome_update_channel = 5;
+inline bool ClientIncidentReport_EnvironmentData_Process::_internal_has_chrome_update_channel() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::has_chrome_update_channel() const {
+  return _internal_has_chrome_update_channel();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_chrome_update_channel() {
+  _impl_.chrome_update_channel_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::_internal_chrome_update_channel() const {
+  return static_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel >(_impl_.chrome_update_channel_);
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::chrome_update_channel() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.chrome_update_channel)
+  return _internal_chrome_update_channel();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::_internal_set_chrome_update_channel(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel value) {
+  assert(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.chrome_update_channel_ = value;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_chrome_update_channel(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel value) {
+  _internal_set_chrome_update_channel(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.chrome_update_channel)
+}
+
+// optional int64 uptime_msec = 6;
+inline bool ClientIncidentReport_EnvironmentData_Process::_internal_has_uptime_msec() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::has_uptime_msec() const {
+  return _internal_has_uptime_msec();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_uptime_msec() {
+  _impl_.uptime_msec_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int64_t ClientIncidentReport_EnvironmentData_Process::_internal_uptime_msec() const {
+  return _impl_.uptime_msec_;
+}
+inline int64_t ClientIncidentReport_EnvironmentData_Process::uptime_msec() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.uptime_msec)
+  return _internal_uptime_msec();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::_internal_set_uptime_msec(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.uptime_msec_ = value;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_uptime_msec(int64_t value) {
+  _internal_set_uptime_msec(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.uptime_msec)
+}
+
+// optional bool metrics_consent = 7;
+inline bool ClientIncidentReport_EnvironmentData_Process::_internal_has_metrics_consent() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::has_metrics_consent() const {
+  return _internal_has_metrics_consent();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_metrics_consent() {
+  _impl_.metrics_consent_ = false;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::_internal_metrics_consent() const {
+  return _impl_.metrics_consent_;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::metrics_consent() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.metrics_consent)
+  return _internal_metrics_consent();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::_internal_set_metrics_consent(bool value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.metrics_consent_ = value;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_metrics_consent(bool value) {
+  _internal_set_metrics_consent(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.metrics_consent)
+}
+
+// optional bool OBSOLETE_extended_consent = 8;
+inline bool ClientIncidentReport_EnvironmentData_Process::_internal_has_obsolete_extended_consent() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::has_obsolete_extended_consent() const {
+  return _internal_has_obsolete_extended_consent();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_obsolete_extended_consent() {
+  _impl_.obsolete_extended_consent_ = false;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::_internal_obsolete_extended_consent() const {
+  return _impl_.obsolete_extended_consent_;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::obsolete_extended_consent() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_extended_consent)
+  return _internal_obsolete_extended_consent();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::_internal_set_obsolete_extended_consent(bool value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.obsolete_extended_consent_ = value;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_obsolete_extended_consent(bool value) {
+  _internal_set_obsolete_extended_consent(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_extended_consent)
+}
+
+// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll dll = 9;
+inline int ClientIncidentReport_EnvironmentData_Process::_internal_dll_size() const {
+  return _impl_.dll_.size();
+}
+inline int ClientIncidentReport_EnvironmentData_Process::dll_size() const {
+  return _internal_dll_size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_dll() {
+  _impl_.dll_.Clear();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll* ClientIncidentReport_EnvironmentData_Process::mutable_dll(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.dll)
+  return _impl_.dll_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll >*
+ClientIncidentReport_EnvironmentData_Process::mutable_dll() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.dll)
+  return &_impl_.dll_;
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll& ClientIncidentReport_EnvironmentData_Process::_internal_dll(int index) const {
+  return _impl_.dll_.Get(index);
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll& ClientIncidentReport_EnvironmentData_Process::dll(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.dll)
+  return _internal_dll(index);
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll* ClientIncidentReport_EnvironmentData_Process::_internal_add_dll() {
+  return _impl_.dll_.Add();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll* ClientIncidentReport_EnvironmentData_Process::add_dll() {
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll* _add = _internal_add_dll();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.dll)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll >&
+ClientIncidentReport_EnvironmentData_Process::dll() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.dll)
+  return _impl_.dll_;
+}
+
+// repeated string blacklisted_dll = 10;
+inline int ClientIncidentReport_EnvironmentData_Process::_internal_blacklisted_dll_size() const {
+  return _impl_.blacklisted_dll_.size();
+}
+inline int ClientIncidentReport_EnvironmentData_Process::blacklisted_dll_size() const {
+  return _internal_blacklisted_dll_size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_blacklisted_dll() {
+  _impl_.blacklisted_dll_.Clear();
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process::add_blacklisted_dll() {
+  std::string* _s = _internal_add_blacklisted_dll();
+  // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process::_internal_blacklisted_dll(int index) const {
+  return _impl_.blacklisted_dll_.Get(index);
+}
+inline const std::string& ClientIncidentReport_EnvironmentData_Process::blacklisted_dll(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll)
+  return _internal_blacklisted_dll(index);
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process::mutable_blacklisted_dll(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll)
+  return _impl_.blacklisted_dll_.Mutable(index);
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_blacklisted_dll(int index, const std::string& value) {
+  _impl_.blacklisted_dll_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll)
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_blacklisted_dll(int index, std::string&& value) {
+  _impl_.blacklisted_dll_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll)
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_blacklisted_dll(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.blacklisted_dll_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll)
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_blacklisted_dll(int index, const char* value, size_t size) {
+  _impl_.blacklisted_dll_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll)
+}
+inline std::string* ClientIncidentReport_EnvironmentData_Process::_internal_add_blacklisted_dll() {
+  return _impl_.blacklisted_dll_.Add();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::add_blacklisted_dll(const std::string& value) {
+  _impl_.blacklisted_dll_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll)
+}
+inline void ClientIncidentReport_EnvironmentData_Process::add_blacklisted_dll(std::string&& value) {
+  _impl_.blacklisted_dll_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll)
+}
+inline void ClientIncidentReport_EnvironmentData_Process::add_blacklisted_dll(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.blacklisted_dll_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll)
+}
+inline void ClientIncidentReport_EnvironmentData_Process::add_blacklisted_dll(const char* value, size_t size) {
+  _impl_.blacklisted_dll_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ClientIncidentReport_EnvironmentData_Process::blacklisted_dll() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll)
+  return _impl_.blacklisted_dll_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ClientIncidentReport_EnvironmentData_Process::mutable_blacklisted_dll() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll)
+  return &_impl_.blacklisted_dll_;
+}
+
+// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState module_state = 11;
+inline int ClientIncidentReport_EnvironmentData_Process::_internal_module_state_size() const {
+  return _impl_.module_state_.size();
+}
+inline int ClientIncidentReport_EnvironmentData_Process::module_state_size() const {
+  return _internal_module_state_size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_module_state() {
+  _impl_.module_state_.Clear();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState* ClientIncidentReport_EnvironmentData_Process::mutable_module_state(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.module_state)
+  return _impl_.module_state_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState >*
+ClientIncidentReport_EnvironmentData_Process::mutable_module_state() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.module_state)
+  return &_impl_.module_state_;
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState& ClientIncidentReport_EnvironmentData_Process::_internal_module_state(int index) const {
+  return _impl_.module_state_.Get(index);
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState& ClientIncidentReport_EnvironmentData_Process::module_state(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.module_state)
+  return _internal_module_state(index);
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState* ClientIncidentReport_EnvironmentData_Process::_internal_add_module_state() {
+  return _impl_.module_state_.Add();
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState* ClientIncidentReport_EnvironmentData_Process::add_module_state() {
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState* _add = _internal_add_module_state();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.module_state)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState >&
+ClientIncidentReport_EnvironmentData_Process::module_state() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.module_state)
+  return _impl_.module_state_;
+}
+
+// optional bool OBSOLETE_field_trial_participant = 12;
+inline bool ClientIncidentReport_EnvironmentData_Process::_internal_has_obsolete_field_trial_participant() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::has_obsolete_field_trial_participant() const {
+  return _internal_has_obsolete_field_trial_participant();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_obsolete_field_trial_participant() {
+  _impl_.obsolete_field_trial_participant_ = false;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::_internal_obsolete_field_trial_participant() const {
+  return _impl_.obsolete_field_trial_participant_;
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::obsolete_field_trial_participant() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_field_trial_participant)
+  return _internal_obsolete_field_trial_participant();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::_internal_set_obsolete_field_trial_participant(bool value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.obsolete_field_trial_participant_ = value;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_obsolete_field_trial_participant(bool value) {
+  _internal_set_obsolete_field_trial_participant(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_field_trial_participant)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData
+
+// optional .safe_browsing.ClientIncidentReport.EnvironmentData.OS os = 1;
+inline bool ClientIncidentReport_EnvironmentData::_internal_has_os() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.os_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData::has_os() const {
+  return _internal_has_os();
+}
+inline void ClientIncidentReport_EnvironmentData::clear_os() {
+  if (_impl_.os_ != nullptr) _impl_.os_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS& ClientIncidentReport_EnvironmentData::_internal_os() const {
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* p = _impl_.os_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS&>(
+      ::safe_browsing::_ClientIncidentReport_EnvironmentData_OS_default_instance_);
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS& ClientIncidentReport_EnvironmentData::os() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.os)
+  return _internal_os();
+}
+inline void ClientIncidentReport_EnvironmentData::unsafe_arena_set_allocated_os(
+    ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* os) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.os_);
+  }
+  _impl_.os_ = os;
+  if (os) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.os)
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* ClientIncidentReport_EnvironmentData::release_os() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* temp = _impl_.os_;
+  _impl_.os_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* ClientIncidentReport_EnvironmentData::unsafe_arena_release_os() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.os)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* temp = _impl_.os_;
+  _impl_.os_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* ClientIncidentReport_EnvironmentData::_internal_mutable_os() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.os_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_OS>(GetArenaForAllocation());
+    _impl_.os_ = p;
+  }
+  return _impl_.os_;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* ClientIncidentReport_EnvironmentData::mutable_os() {
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* _msg = _internal_mutable_os();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.os)
+  return _msg;
+}
+inline void ClientIncidentReport_EnvironmentData::set_allocated_os(::safe_browsing::ClientIncidentReport_EnvironmentData_OS* os) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.os_;
+  }
+  if (os) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(os);
+    if (message_arena != submessage_arena) {
+      os = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, os, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.os_ = os;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.os)
+}
+
+// optional .safe_browsing.ClientIncidentReport.EnvironmentData.Machine machine = 2;
+inline bool ClientIncidentReport_EnvironmentData::_internal_has_machine() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.machine_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData::has_machine() const {
+  return _internal_has_machine();
+}
+inline void ClientIncidentReport_EnvironmentData::clear_machine() {
+  if (_impl_.machine_ != nullptr) _impl_.machine_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine& ClientIncidentReport_EnvironmentData::_internal_machine() const {
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* p = _impl_.machine_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine&>(
+      ::safe_browsing::_ClientIncidentReport_EnvironmentData_Machine_default_instance_);
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine& ClientIncidentReport_EnvironmentData::machine() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.machine)
+  return _internal_machine();
+}
+inline void ClientIncidentReport_EnvironmentData::unsafe_arena_set_allocated_machine(
+    ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* machine) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.machine_);
+  }
+  _impl_.machine_ = machine;
+  if (machine) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.machine)
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* ClientIncidentReport_EnvironmentData::release_machine() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* temp = _impl_.machine_;
+  _impl_.machine_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* ClientIncidentReport_EnvironmentData::unsafe_arena_release_machine() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.machine)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* temp = _impl_.machine_;
+  _impl_.machine_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* ClientIncidentReport_EnvironmentData::_internal_mutable_machine() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.machine_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_Machine>(GetArenaForAllocation());
+    _impl_.machine_ = p;
+  }
+  return _impl_.machine_;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* ClientIncidentReport_EnvironmentData::mutable_machine() {
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* _msg = _internal_mutable_machine();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.machine)
+  return _msg;
+}
+inline void ClientIncidentReport_EnvironmentData::set_allocated_machine(::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* machine) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.machine_;
+  }
+  if (machine) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(machine);
+    if (message_arena != submessage_arena) {
+      machine = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, machine, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.machine_ = machine;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.machine)
+}
+
+// optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process process = 3;
+inline bool ClientIncidentReport_EnvironmentData::_internal_has_process() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.process_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport_EnvironmentData::has_process() const {
+  return _internal_has_process();
+}
+inline void ClientIncidentReport_EnvironmentData::clear_process() {
+  if (_impl_.process_ != nullptr) _impl_.process_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process& ClientIncidentReport_EnvironmentData::_internal_process() const {
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* p = _impl_.process_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process&>(
+      ::safe_browsing::_ClientIncidentReport_EnvironmentData_Process_default_instance_);
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process& ClientIncidentReport_EnvironmentData::process() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.process)
+  return _internal_process();
+}
+inline void ClientIncidentReport_EnvironmentData::unsafe_arena_set_allocated_process(
+    ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* process) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.process_);
+  }
+  _impl_.process_ = process;
+  if (process) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.process)
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* ClientIncidentReport_EnvironmentData::release_process() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* temp = _impl_.process_;
+  _impl_.process_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* ClientIncidentReport_EnvironmentData::unsafe_arena_release_process() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.process)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* temp = _impl_.process_;
+  _impl_.process_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* ClientIncidentReport_EnvironmentData::_internal_mutable_process() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.process_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_Process>(GetArenaForAllocation());
+    _impl_.process_ = p;
+  }
+  return _impl_.process_;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* ClientIncidentReport_EnvironmentData::mutable_process() {
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* _msg = _internal_mutable_process();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.process)
+  return _msg;
+}
+inline void ClientIncidentReport_EnvironmentData::set_allocated_process(::safe_browsing::ClientIncidentReport_EnvironmentData_Process* process) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.process_;
+  }
+  if (process) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(process);
+    if (message_arena != submessage_arena) {
+      process = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, process, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.process_ = process;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.process)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_ExtensionData_ExtensionInfo
+
+// optional string id = 1;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_id() const {
+  return _internal_has_id();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_id() {
+  _impl_.id_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::id() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_ExtensionData_ExtensionInfo::set_id(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id)
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_id() const {
+  return _impl_.id_.Get();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_id(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.id_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_mutable_id() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.id_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::release_id() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.id_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.id_.IsDefault()) {
+    _impl_.id_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id)
+}
+
+// optional string version = 2;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_version() const {
+  return _internal_has_version();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_version() {
+  _impl_.version_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version)
+  return _internal_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_ExtensionData_ExtensionInfo::set_version(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version)
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_version() {
+  std::string* _s = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_version() const {
+  return _impl_.version_.Get();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_version(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.version_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_mutable_version() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.version_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::release_version() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version)
+  if (!_internal_has_version()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.version_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_.IsDefault()) {
+    _impl_.version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_version(std::string* version) {
+  if (version != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_.IsDefault()) {
+    _impl_.version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version)
+}
+
+// optional string name = 3;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_name() const {
+  return _internal_has_name();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_ExtensionData_ExtensionInfo::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name)
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::release_name() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name)
+}
+
+// optional string description = 4;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_description() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_description() const {
+  return _internal_has_description();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_description() {
+  _impl_.description_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::description() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_ExtensionData_ExtensionInfo::set_description(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description)
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_description() const {
+  return _impl_.description_.Get();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_description(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.description_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_mutable_description() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.description_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::release_description() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description)
+  if (!_internal_has_description()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.description_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.description_.IsDefault()) {
+    _impl_.description_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description)
+}
+
+// optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.ExtensionState state = 5 [default = STATE_UNKNOWN];
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_state() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_state() const {
+  return _internal_has_state();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_state() {
+  _impl_.state_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_state() const {
+  return static_cast< ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState >(_impl_.state_);
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::state() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.state)
+  return _internal_state();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_state(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState value) {
+  assert(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.state_ = value;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_state(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState value) {
+  _internal_set_state(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.state)
+}
+
+// optional int32 type = 6;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_type() const {
+  return _internal_has_type();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_type() {
+  _impl_.type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline int32_t ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_type() const {
+  return _impl_.type_;
+}
+inline int32_t ClientIncidentReport_ExtensionData_ExtensionInfo::type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.type)
+  return _internal_type();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_type(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.type_ = value;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_type(int32_t value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.type)
+}
+
+// optional string update_url = 7;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_update_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_update_url() const {
+  return _internal_has_update_url();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_update_url() {
+  _impl_.update_url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::update_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url)
+  return _internal_update_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_ExtensionData_ExtensionInfo::set_update_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.update_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url)
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_update_url() {
+  std::string* _s = _internal_mutable_update_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_update_url() const {
+  return _impl_.update_url_.Get();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_update_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.update_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_mutable_update_url() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.update_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::release_update_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url)
+  if (!_internal_has_update_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.update_url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.update_url_.IsDefault()) {
+    _impl_.update_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_update_url(std::string* update_url) {
+  if (update_url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.update_url_.SetAllocated(update_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.update_url_.IsDefault()) {
+    _impl_.update_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url)
+}
+
+// optional bool has_signature_validation = 8;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_has_signature_validation() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_has_signature_validation() const {
+  return _internal_has_has_signature_validation();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_signature_validation() {
+  _impl_.has_signature_validation_ = false;
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_signature_validation() const {
+  return _impl_.has_signature_validation_;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_signature_validation() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.has_signature_validation)
+  return _internal_has_signature_validation();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_has_signature_validation(bool value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.has_signature_validation_ = value;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_signature_validation(bool value) {
+  _internal_set_has_signature_validation(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.has_signature_validation)
+}
+
+// optional bool signature_is_valid = 9;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_signature_is_valid() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_signature_is_valid() const {
+  return _internal_has_signature_is_valid();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_signature_is_valid() {
+  _impl_.signature_is_valid_ = false;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_signature_is_valid() const {
+  return _impl_.signature_is_valid_;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::signature_is_valid() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.signature_is_valid)
+  return _internal_signature_is_valid();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_signature_is_valid(bool value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.signature_is_valid_ = value;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_signature_is_valid(bool value) {
+  _internal_set_signature_is_valid(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.signature_is_valid)
+}
+
+// optional bool installed_by_custodian = 10;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_installed_by_custodian() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_installed_by_custodian() const {
+  return _internal_has_installed_by_custodian();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_installed_by_custodian() {
+  _impl_.installed_by_custodian_ = false;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_installed_by_custodian() const {
+  return _impl_.installed_by_custodian_;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::installed_by_custodian() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.installed_by_custodian)
+  return _internal_installed_by_custodian();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_installed_by_custodian(bool value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.installed_by_custodian_ = value;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_installed_by_custodian(bool value) {
+  _internal_set_installed_by_custodian(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.installed_by_custodian)
+}
+
+// optional bool installed_by_default = 11;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_installed_by_default() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_installed_by_default() const {
+  return _internal_has_installed_by_default();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_installed_by_default() {
+  _impl_.installed_by_default_ = false;
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_installed_by_default() const {
+  return _impl_.installed_by_default_;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::installed_by_default() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.installed_by_default)
+  return _internal_installed_by_default();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_installed_by_default(bool value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.installed_by_default_ = value;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_installed_by_default(bool value) {
+  _internal_set_installed_by_default(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.installed_by_default)
+}
+
+// optional bool installed_by_oem = 12;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_installed_by_oem() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_installed_by_oem() const {
+  return _internal_has_installed_by_oem();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_installed_by_oem() {
+  _impl_.installed_by_oem_ = false;
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_installed_by_oem() const {
+  return _impl_.installed_by_oem_;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::installed_by_oem() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.installed_by_oem)
+  return _internal_installed_by_oem();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_installed_by_oem(bool value) {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  _impl_.installed_by_oem_ = value;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_installed_by_oem(bool value) {
+  _internal_set_installed_by_oem(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.installed_by_oem)
+}
+
+// optional bool from_bookmark = 13;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_from_bookmark() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_from_bookmark() const {
+  return _internal_has_from_bookmark();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_from_bookmark() {
+  _impl_.from_bookmark_ = false;
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_from_bookmark() const {
+  return _impl_.from_bookmark_;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::from_bookmark() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.from_bookmark)
+  return _internal_from_bookmark();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_from_bookmark(bool value) {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  _impl_.from_bookmark_ = value;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_from_bookmark(bool value) {
+  _internal_set_from_bookmark(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.from_bookmark)
+}
+
+// optional bool from_webstore = 14;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_from_webstore() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_from_webstore() const {
+  return _internal_has_from_webstore();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_from_webstore() {
+  _impl_.from_webstore_ = false;
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_from_webstore() const {
+  return _impl_.from_webstore_;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::from_webstore() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.from_webstore)
+  return _internal_from_webstore();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_from_webstore(bool value) {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  _impl_.from_webstore_ = value;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_from_webstore(bool value) {
+  _internal_set_from_webstore(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.from_webstore)
+}
+
+// optional bool converted_from_user_script = 15;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_converted_from_user_script() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_converted_from_user_script() const {
+  return _internal_has_converted_from_user_script();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_converted_from_user_script() {
+  _impl_.converted_from_user_script_ = false;
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_converted_from_user_script() const {
+  return _impl_.converted_from_user_script_;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::converted_from_user_script() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.converted_from_user_script)
+  return _internal_converted_from_user_script();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_converted_from_user_script(bool value) {
+  _impl_._has_bits_[0] |= 0x00008000u;
+  _impl_.converted_from_user_script_ = value;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_converted_from_user_script(bool value) {
+  _internal_set_converted_from_user_script(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.converted_from_user_script)
+}
+
+// optional bool may_be_untrusted = 16;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_may_be_untrusted() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_may_be_untrusted() const {
+  return _internal_has_may_be_untrusted();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_may_be_untrusted() {
+  _impl_.may_be_untrusted_ = false;
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_may_be_untrusted() const {
+  return _impl_.may_be_untrusted_;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::may_be_untrusted() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.may_be_untrusted)
+  return _internal_may_be_untrusted();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_may_be_untrusted(bool value) {
+  _impl_._has_bits_[0] |= 0x00020000u;
+  _impl_.may_be_untrusted_ = value;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_may_be_untrusted(bool value) {
+  _internal_set_may_be_untrusted(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.may_be_untrusted)
+}
+
+// optional int64 install_time_msec = 17;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_install_time_msec() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_install_time_msec() const {
+  return _internal_has_install_time_msec();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_install_time_msec() {
+  _impl_.install_time_msec_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline int64_t ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_install_time_msec() const {
+  return _impl_.install_time_msec_;
+}
+inline int64_t ClientIncidentReport_ExtensionData_ExtensionInfo::install_time_msec() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.install_time_msec)
+  return _internal_install_time_msec();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_install_time_msec(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00010000u;
+  _impl_.install_time_msec_ = value;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_install_time_msec(int64_t value) {
+  _internal_set_install_time_msec(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.install_time_msec)
+}
+
+// optional int32 manifest_location_type = 18;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_manifest_location_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_manifest_location_type() const {
+  return _internal_has_manifest_location_type();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_manifest_location_type() {
+  _impl_.manifest_location_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline int32_t ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_manifest_location_type() const {
+  return _impl_.manifest_location_type_;
+}
+inline int32_t ClientIncidentReport_ExtensionData_ExtensionInfo::manifest_location_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest_location_type)
+  return _internal_manifest_location_type();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_manifest_location_type(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00040000u;
+  _impl_.manifest_location_type_ = value;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_manifest_location_type(int32_t value) {
+  _internal_set_manifest_location_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest_location_type)
+}
+
+// optional string manifest = 19;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_manifest() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_manifest() const {
+  return _internal_has_manifest();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_manifest() {
+  _impl_.manifest_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::manifest() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest)
+  return _internal_manifest();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_ExtensionData_ExtensionInfo::set_manifest(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.manifest_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest)
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_manifest() {
+  std::string* _s = _internal_mutable_manifest();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_manifest() const {
+  return _impl_.manifest_.Get();
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_manifest(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.manifest_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_mutable_manifest() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.manifest_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::release_manifest() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest)
+  if (!_internal_has_manifest()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.manifest_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.manifest_.IsDefault()) {
+    _impl_.manifest_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_manifest(std::string* manifest) {
+  if (manifest != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.manifest_.SetAllocated(manifest, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.manifest_.IsDefault()) {
+    _impl_.manifest_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_ExtensionData
+
+// optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo last_installed_extension = 1;
+inline bool ClientIncidentReport_ExtensionData::_internal_has_last_installed_extension() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.last_installed_extension_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport_ExtensionData::has_last_installed_extension() const {
+  return _internal_has_last_installed_extension();
+}
+inline void ClientIncidentReport_ExtensionData::clear_last_installed_extension() {
+  if (_impl_.last_installed_extension_ != nullptr) _impl_.last_installed_extension_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo& ClientIncidentReport_ExtensionData::_internal_last_installed_extension() const {
+  const ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* p = _impl_.last_installed_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo&>(
+      ::safe_browsing::_ClientIncidentReport_ExtensionData_ExtensionInfo_default_instance_);
+}
+inline const ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo& ClientIncidentReport_ExtensionData::last_installed_extension() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.last_installed_extension)
+  return _internal_last_installed_extension();
+}
+inline void ClientIncidentReport_ExtensionData::unsafe_arena_set_allocated_last_installed_extension(
+    ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* last_installed_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.last_installed_extension_);
+  }
+  _impl_.last_installed_extension_ = last_installed_extension;
+  if (last_installed_extension) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.ExtensionData.last_installed_extension)
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* ClientIncidentReport_ExtensionData::release_last_installed_extension() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* temp = _impl_.last_installed_extension_;
+  _impl_.last_installed_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* ClientIncidentReport_ExtensionData::unsafe_arena_release_last_installed_extension() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.ExtensionData.last_installed_extension)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* temp = _impl_.last_installed_extension_;
+  _impl_.last_installed_extension_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* ClientIncidentReport_ExtensionData::_internal_mutable_last_installed_extension() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.last_installed_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo>(GetArenaForAllocation());
+    _impl_.last_installed_extension_ = p;
+  }
+  return _impl_.last_installed_extension_;
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* ClientIncidentReport_ExtensionData::mutable_last_installed_extension() {
+  ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* _msg = _internal_mutable_last_installed_extension();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.last_installed_extension)
+  return _msg;
+}
+inline void ClientIncidentReport_ExtensionData::set_allocated_last_installed_extension(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* last_installed_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.last_installed_extension_;
+  }
+  if (last_installed_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(last_installed_extension);
+    if (message_arena != submessage_arena) {
+      last_installed_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, last_installed_extension, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.last_installed_extension_ = last_installed_extension;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.ExtensionData.last_installed_extension)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_NonBinaryDownloadDetails
+
+// optional string file_type = 1;
+inline bool ClientIncidentReport_NonBinaryDownloadDetails::_internal_has_file_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_NonBinaryDownloadDetails::has_file_type() const {
+  return _internal_has_file_type();
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_file_type() {
+  _impl_.file_type_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentReport_NonBinaryDownloadDetails::file_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type)
+  return _internal_file_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_NonBinaryDownloadDetails::set_file_type(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.file_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type)
+}
+inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::mutable_file_type() {
+  std::string* _s = _internal_mutable_file_type();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_NonBinaryDownloadDetails::_internal_file_type() const {
+  return _impl_.file_type_.Get();
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::_internal_set_file_type(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.file_type_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::_internal_mutable_file_type() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.file_type_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::release_file_type() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type)
+  if (!_internal_has_file_type()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.file_type_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.file_type_.IsDefault()) {
+    _impl_.file_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_allocated_file_type(std::string* file_type) {
+  if (file_type != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.file_type_.SetAllocated(file_type, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.file_type_.IsDefault()) {
+    _impl_.file_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type)
+}
+
+// optional bytes url_spec_sha256 = 2;
+inline bool ClientIncidentReport_NonBinaryDownloadDetails::_internal_has_url_spec_sha256() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_NonBinaryDownloadDetails::has_url_spec_sha256() const {
+  return _internal_has_url_spec_sha256();
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_url_spec_sha256() {
+  _impl_.url_spec_sha256_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientIncidentReport_NonBinaryDownloadDetails::url_spec_sha256() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256)
+  return _internal_url_spec_sha256();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_NonBinaryDownloadDetails::set_url_spec_sha256(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.url_spec_sha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256)
+}
+inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::mutable_url_spec_sha256() {
+  std::string* _s = _internal_mutable_url_spec_sha256();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_NonBinaryDownloadDetails::_internal_url_spec_sha256() const {
+  return _impl_.url_spec_sha256_.Get();
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::_internal_set_url_spec_sha256(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.url_spec_sha256_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::_internal_mutable_url_spec_sha256() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.url_spec_sha256_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::release_url_spec_sha256() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256)
+  if (!_internal_has_url_spec_sha256()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.url_spec_sha256_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_spec_sha256_.IsDefault()) {
+    _impl_.url_spec_sha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_allocated_url_spec_sha256(std::string* url_spec_sha256) {
+  if (url_spec_sha256 != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.url_spec_sha256_.SetAllocated(url_spec_sha256, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_spec_sha256_.IsDefault()) {
+    _impl_.url_spec_sha256_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256)
+}
+
+// optional string host = 3;
+inline bool ClientIncidentReport_NonBinaryDownloadDetails::_internal_has_host() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_NonBinaryDownloadDetails::has_host() const {
+  return _internal_has_host();
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_host() {
+  _impl_.host_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientIncidentReport_NonBinaryDownloadDetails::host() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host)
+  return _internal_host();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentReport_NonBinaryDownloadDetails::set_host(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.host_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host)
+}
+inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::mutable_host() {
+  std::string* _s = _internal_mutable_host();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host)
+  return _s;
+}
+inline const std::string& ClientIncidentReport_NonBinaryDownloadDetails::_internal_host() const {
+  return _impl_.host_.Get();
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::_internal_set_host(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.host_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::_internal_mutable_host() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.host_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::release_host() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host)
+  if (!_internal_has_host()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.host_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.host_.IsDefault()) {
+    _impl_.host_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_allocated_host(std::string* host) {
+  if (host != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.host_.SetAllocated(host, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.host_.IsDefault()) {
+    _impl_.host_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host)
+}
+
+// optional int64 length = 4;
+inline bool ClientIncidentReport_NonBinaryDownloadDetails::_internal_has_length() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientIncidentReport_NonBinaryDownloadDetails::has_length() const {
+  return _internal_has_length();
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_length() {
+  _impl_.length_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int64_t ClientIncidentReport_NonBinaryDownloadDetails::_internal_length() const {
+  return _impl_.length_;
+}
+inline int64_t ClientIncidentReport_NonBinaryDownloadDetails::length() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.length)
+  return _internal_length();
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::_internal_set_length(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.length_ = value;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_length(int64_t value) {
+  _internal_set_length(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.length)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport
+
+// repeated .safe_browsing.ClientIncidentReport.IncidentData incident = 1;
+inline int ClientIncidentReport::_internal_incident_size() const {
+  return _impl_.incident_.size();
+}
+inline int ClientIncidentReport::incident_size() const {
+  return _internal_incident_size();
+}
+inline void ClientIncidentReport::clear_incident() {
+  _impl_.incident_.Clear();
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData* ClientIncidentReport::mutable_incident(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.incident)
+  return _impl_.incident_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData >*
+ClientIncidentReport::mutable_incident() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.incident)
+  return &_impl_.incident_;
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData& ClientIncidentReport::_internal_incident(int index) const {
+  return _impl_.incident_.Get(index);
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData& ClientIncidentReport::incident(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.incident)
+  return _internal_incident(index);
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData* ClientIncidentReport::_internal_add_incident() {
+  return _impl_.incident_.Add();
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData* ClientIncidentReport::add_incident() {
+  ::safe_browsing::ClientIncidentReport_IncidentData* _add = _internal_add_incident();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.incident)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData >&
+ClientIncidentReport::incident() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.incident)
+  return _impl_.incident_;
+}
+
+// optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+inline bool ClientIncidentReport::_internal_has_download() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.download_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport::has_download() const {
+  return _internal_has_download();
+}
+inline void ClientIncidentReport::clear_download() {
+  if (_impl_.download_ != nullptr) _impl_.download_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::safe_browsing::ClientIncidentReport_DownloadDetails& ClientIncidentReport::_internal_download() const {
+  const ::safe_browsing::ClientIncidentReport_DownloadDetails* p = _impl_.download_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientIncidentReport_DownloadDetails&>(
+      ::safe_browsing::_ClientIncidentReport_DownloadDetails_default_instance_);
+}
+inline const ::safe_browsing::ClientIncidentReport_DownloadDetails& ClientIncidentReport::download() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.download)
+  return _internal_download();
+}
+inline void ClientIncidentReport::unsafe_arena_set_allocated_download(
+    ::safe_browsing::ClientIncidentReport_DownloadDetails* download) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.download_);
+  }
+  _impl_.download_ = download;
+  if (download) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.download)
+}
+inline ::safe_browsing::ClientIncidentReport_DownloadDetails* ClientIncidentReport::release_download() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* temp = _impl_.download_;
+  _impl_.download_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_DownloadDetails* ClientIncidentReport::unsafe_arena_release_download() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.download)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* temp = _impl_.download_;
+  _impl_.download_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_DownloadDetails* ClientIncidentReport::_internal_mutable_download() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.download_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_DownloadDetails>(GetArenaForAllocation());
+    _impl_.download_ = p;
+  }
+  return _impl_.download_;
+}
+inline ::safe_browsing::ClientIncidentReport_DownloadDetails* ClientIncidentReport::mutable_download() {
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* _msg = _internal_mutable_download();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.download)
+  return _msg;
+}
+inline void ClientIncidentReport::set_allocated_download(::safe_browsing::ClientIncidentReport_DownloadDetails* download) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.download_;
+  }
+  if (download) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(download);
+    if (message_arena != submessage_arena) {
+      download = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, download, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.download_ = download;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.download)
+}
+
+// optional .safe_browsing.ClientIncidentReport.EnvironmentData environment = 3;
+inline bool ClientIncidentReport::_internal_has_environment() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.environment_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport::has_environment() const {
+  return _internal_has_environment();
+}
+inline void ClientIncidentReport::clear_environment() {
+  if (_impl_.environment_ != nullptr) _impl_.environment_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData& ClientIncidentReport::_internal_environment() const {
+  const ::safe_browsing::ClientIncidentReport_EnvironmentData* p = _impl_.environment_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientIncidentReport_EnvironmentData&>(
+      ::safe_browsing::_ClientIncidentReport_EnvironmentData_default_instance_);
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData& ClientIncidentReport::environment() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.environment)
+  return _internal_environment();
+}
+inline void ClientIncidentReport::unsafe_arena_set_allocated_environment(
+    ::safe_browsing::ClientIncidentReport_EnvironmentData* environment) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.environment_);
+  }
+  _impl_.environment_ = environment;
+  if (environment) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.environment)
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData* ClientIncidentReport::release_environment() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData* temp = _impl_.environment_;
+  _impl_.environment_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData* ClientIncidentReport::unsafe_arena_release_environment() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.environment)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData* temp = _impl_.environment_;
+  _impl_.environment_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData* ClientIncidentReport::_internal_mutable_environment() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.environment_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData>(GetArenaForAllocation());
+    _impl_.environment_ = p;
+  }
+  return _impl_.environment_;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData* ClientIncidentReport::mutable_environment() {
+  ::safe_browsing::ClientIncidentReport_EnvironmentData* _msg = _internal_mutable_environment();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.environment)
+  return _msg;
+}
+inline void ClientIncidentReport::set_allocated_environment(::safe_browsing::ClientIncidentReport_EnvironmentData* environment) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.environment_;
+  }
+  if (environment) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(environment);
+    if (message_arena != submessage_arena) {
+      environment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, environment, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.environment_ = environment;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.environment)
+}
+
+// optional .safe_browsing.ChromeUserPopulation population = 7;
+inline bool ClientIncidentReport::_internal_has_population() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.population_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport::has_population() const {
+  return _internal_has_population();
+}
+inline void ClientIncidentReport::clear_population() {
+  if (_impl_.population_ != nullptr) _impl_.population_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::safe_browsing::ChromeUserPopulation& ClientIncidentReport::_internal_population() const {
+  const ::safe_browsing::ChromeUserPopulation* p = _impl_.population_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ChromeUserPopulation&>(
+      ::safe_browsing::_ChromeUserPopulation_default_instance_);
+}
+inline const ::safe_browsing::ChromeUserPopulation& ClientIncidentReport::population() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.population)
+  return _internal_population();
+}
+inline void ClientIncidentReport::unsafe_arena_set_allocated_population(
+    ::safe_browsing::ChromeUserPopulation* population) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.population_);
+  }
+  _impl_.population_ = population;
+  if (population) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.population)
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientIncidentReport::release_population() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ChromeUserPopulation* temp = _impl_.population_;
+  _impl_.population_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientIncidentReport::unsafe_arena_release_population() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.population)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ChromeUserPopulation* temp = _impl_.population_;
+  _impl_.population_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientIncidentReport::_internal_mutable_population() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.population_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ChromeUserPopulation>(GetArenaForAllocation());
+    _impl_.population_ = p;
+  }
+  return _impl_.population_;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientIncidentReport::mutable_population() {
+  ::safe_browsing::ChromeUserPopulation* _msg = _internal_mutable_population();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.population)
+  return _msg;
+}
+inline void ClientIncidentReport::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.population_;
+  }
+  if (population) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(population);
+    if (message_arena != submessage_arena) {
+      population = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, population, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.population_ = population;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.population)
+}
+
+// optional .safe_browsing.ClientIncidentReport.ExtensionData extension_data = 8;
+inline bool ClientIncidentReport::_internal_has_extension_data() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.extension_data_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport::has_extension_data() const {
+  return _internal_has_extension_data();
+}
+inline void ClientIncidentReport::clear_extension_data() {
+  if (_impl_.extension_data_ != nullptr) _impl_.extension_data_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::safe_browsing::ClientIncidentReport_ExtensionData& ClientIncidentReport::_internal_extension_data() const {
+  const ::safe_browsing::ClientIncidentReport_ExtensionData* p = _impl_.extension_data_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientIncidentReport_ExtensionData&>(
+      ::safe_browsing::_ClientIncidentReport_ExtensionData_default_instance_);
+}
+inline const ::safe_browsing::ClientIncidentReport_ExtensionData& ClientIncidentReport::extension_data() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.extension_data)
+  return _internal_extension_data();
+}
+inline void ClientIncidentReport::unsafe_arena_set_allocated_extension_data(
+    ::safe_browsing::ClientIncidentReport_ExtensionData* extension_data) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.extension_data_);
+  }
+  _impl_.extension_data_ = extension_data;
+  if (extension_data) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.extension_data)
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData* ClientIncidentReport::release_extension_data() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::safe_browsing::ClientIncidentReport_ExtensionData* temp = _impl_.extension_data_;
+  _impl_.extension_data_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData* ClientIncidentReport::unsafe_arena_release_extension_data() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.extension_data)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::safe_browsing::ClientIncidentReport_ExtensionData* temp = _impl_.extension_data_;
+  _impl_.extension_data_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData* ClientIncidentReport::_internal_mutable_extension_data() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.extension_data_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_ExtensionData>(GetArenaForAllocation());
+    _impl_.extension_data_ = p;
+  }
+  return _impl_.extension_data_;
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData* ClientIncidentReport::mutable_extension_data() {
+  ::safe_browsing::ClientIncidentReport_ExtensionData* _msg = _internal_mutable_extension_data();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.extension_data)
+  return _msg;
+}
+inline void ClientIncidentReport::set_allocated_extension_data(::safe_browsing::ClientIncidentReport_ExtensionData* extension_data) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.extension_data_;
+  }
+  if (extension_data) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(extension_data);
+    if (message_arena != submessage_arena) {
+      extension_data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, extension_data, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.extension_data_ = extension_data;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.extension_data)
+}
+
+// optional .safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails non_binary_download = 9;
+inline bool ClientIncidentReport::_internal_has_non_binary_download() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.non_binary_download_ != nullptr);
+  return value;
+}
+inline bool ClientIncidentReport::has_non_binary_download() const {
+  return _internal_has_non_binary_download();
+}
+inline void ClientIncidentReport::clear_non_binary_download() {
+  if (_impl_.non_binary_download_ != nullptr) _impl_.non_binary_download_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails& ClientIncidentReport::_internal_non_binary_download() const {
+  const ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* p = _impl_.non_binary_download_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails&>(
+      ::safe_browsing::_ClientIncidentReport_NonBinaryDownloadDetails_default_instance_);
+}
+inline const ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails& ClientIncidentReport::non_binary_download() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.non_binary_download)
+  return _internal_non_binary_download();
+}
+inline void ClientIncidentReport::unsafe_arena_set_allocated_non_binary_download(
+    ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* non_binary_download) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.non_binary_download_);
+  }
+  _impl_.non_binary_download_ = non_binary_download;
+  if (non_binary_download) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientIncidentReport.non_binary_download)
+}
+inline ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* ClientIncidentReport::release_non_binary_download() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* temp = _impl_.non_binary_download_;
+  _impl_.non_binary_download_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* ClientIncidentReport::unsafe_arena_release_non_binary_download() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.non_binary_download)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* temp = _impl_.non_binary_download_;
+  _impl_.non_binary_download_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* ClientIncidentReport::_internal_mutable_non_binary_download() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.non_binary_download_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails>(GetArenaForAllocation());
+    _impl_.non_binary_download_ = p;
+  }
+  return _impl_.non_binary_download_;
+}
+inline ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* ClientIncidentReport::mutable_non_binary_download() {
+  ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* _msg = _internal_mutable_non_binary_download();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.non_binary_download)
+  return _msg;
+}
+inline void ClientIncidentReport::set_allocated_non_binary_download(::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* non_binary_download) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.non_binary_download_;
+  }
+  if (non_binary_download) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(non_binary_download);
+    if (message_arena != submessage_arena) {
+      non_binary_download = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, non_binary_download, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.non_binary_download_ = non_binary_download;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.non_binary_download)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentResponse_EnvironmentRequest
+
+// optional int32 dll_index = 1;
+inline bool ClientIncidentResponse_EnvironmentRequest::_internal_has_dll_index() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentResponse_EnvironmentRequest::has_dll_index() const {
+  return _internal_has_dll_index();
+}
+inline void ClientIncidentResponse_EnvironmentRequest::clear_dll_index() {
+  _impl_.dll_index_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int32_t ClientIncidentResponse_EnvironmentRequest::_internal_dll_index() const {
+  return _impl_.dll_index_;
+}
+inline int32_t ClientIncidentResponse_EnvironmentRequest::dll_index() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentResponse.EnvironmentRequest.dll_index)
+  return _internal_dll_index();
+}
+inline void ClientIncidentResponse_EnvironmentRequest::_internal_set_dll_index(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.dll_index_ = value;
+}
+inline void ClientIncidentResponse_EnvironmentRequest::set_dll_index(int32_t value) {
+  _internal_set_dll_index(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentResponse.EnvironmentRequest.dll_index)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentResponse
+
+// optional bytes token = 1;
+inline bool ClientIncidentResponse::_internal_has_token() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIncidentResponse::has_token() const {
+  return _internal_has_token();
+}
+inline void ClientIncidentResponse::clear_token() {
+  _impl_.token_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIncidentResponse::token() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentResponse.token)
+  return _internal_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIncidentResponse::set_token(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.token_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentResponse.token)
+}
+inline std::string* ClientIncidentResponse::mutable_token() {
+  std::string* _s = _internal_mutable_token();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentResponse.token)
+  return _s;
+}
+inline const std::string& ClientIncidentResponse::_internal_token() const {
+  return _impl_.token_.Get();
+}
+inline void ClientIncidentResponse::_internal_set_token(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.token_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientIncidentResponse::_internal_mutable_token() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.token_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientIncidentResponse::release_token() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentResponse.token)
+  if (!_internal_has_token()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.token_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.token_.IsDefault()) {
+    _impl_.token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientIncidentResponse::set_allocated_token(std::string* token) {
+  if (token != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.token_.SetAllocated(token, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.token_.IsDefault()) {
+    _impl_.token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentResponse.token)
+}
+
+// optional bool download_requested = 2;
+inline bool ClientIncidentResponse::_internal_has_download_requested() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIncidentResponse::has_download_requested() const {
+  return _internal_has_download_requested();
+}
+inline void ClientIncidentResponse::clear_download_requested() {
+  _impl_.download_requested_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool ClientIncidentResponse::_internal_download_requested() const {
+  return _impl_.download_requested_;
+}
+inline bool ClientIncidentResponse::download_requested() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentResponse.download_requested)
+  return _internal_download_requested();
+}
+inline void ClientIncidentResponse::_internal_set_download_requested(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.download_requested_ = value;
+}
+inline void ClientIncidentResponse::set_download_requested(bool value) {
+  _internal_set_download_requested(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentResponse.download_requested)
+}
+
+// repeated .safe_browsing.ClientIncidentResponse.EnvironmentRequest environment_requests = 3;
+inline int ClientIncidentResponse::_internal_environment_requests_size() const {
+  return _impl_.environment_requests_.size();
+}
+inline int ClientIncidentResponse::environment_requests_size() const {
+  return _internal_environment_requests_size();
+}
+inline void ClientIncidentResponse::clear_environment_requests() {
+  _impl_.environment_requests_.Clear();
+}
+inline ::safe_browsing::ClientIncidentResponse_EnvironmentRequest* ClientIncidentResponse::mutable_environment_requests(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentResponse.environment_requests)
+  return _impl_.environment_requests_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest >*
+ClientIncidentResponse::mutable_environment_requests() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentResponse.environment_requests)
+  return &_impl_.environment_requests_;
+}
+inline const ::safe_browsing::ClientIncidentResponse_EnvironmentRequest& ClientIncidentResponse::_internal_environment_requests(int index) const {
+  return _impl_.environment_requests_.Get(index);
+}
+inline const ::safe_browsing::ClientIncidentResponse_EnvironmentRequest& ClientIncidentResponse::environment_requests(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentResponse.environment_requests)
+  return _internal_environment_requests(index);
+}
+inline ::safe_browsing::ClientIncidentResponse_EnvironmentRequest* ClientIncidentResponse::_internal_add_environment_requests() {
+  return _impl_.environment_requests_.Add();
+}
+inline ::safe_browsing::ClientIncidentResponse_EnvironmentRequest* ClientIncidentResponse::add_environment_requests() {
+  ::safe_browsing::ClientIncidentResponse_EnvironmentRequest* _add = _internal_add_environment_requests();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentResponse.environment_requests)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest >&
+ClientIncidentResponse::environment_requests() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentResponse.environment_requests)
+  return _impl_.environment_requests_;
+}
+
+// -------------------------------------------------------------------
+
+// DownloadMetadata
+
+// optional uint32 download_id = 1;
+inline bool DownloadMetadata::_internal_has_download_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DownloadMetadata::has_download_id() const {
+  return _internal_has_download_id();
+}
+inline void DownloadMetadata::clear_download_id() {
+  _impl_.download_id_ = 0u;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint32_t DownloadMetadata::_internal_download_id() const {
+  return _impl_.download_id_;
+}
+inline uint32_t DownloadMetadata::download_id() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.DownloadMetadata.download_id)
+  return _internal_download_id();
+}
+inline void DownloadMetadata::_internal_set_download_id(uint32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.download_id_ = value;
+}
+inline void DownloadMetadata::set_download_id(uint32_t value) {
+  _internal_set_download_id(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.DownloadMetadata.download_id)
+}
+
+// optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+inline bool DownloadMetadata::_internal_has_download() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.download_ != nullptr);
+  return value;
+}
+inline bool DownloadMetadata::has_download() const {
+  return _internal_has_download();
+}
+inline void DownloadMetadata::clear_download() {
+  if (_impl_.download_ != nullptr) _impl_.download_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::safe_browsing::ClientIncidentReport_DownloadDetails& DownloadMetadata::_internal_download() const {
+  const ::safe_browsing::ClientIncidentReport_DownloadDetails* p = _impl_.download_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientIncidentReport_DownloadDetails&>(
+      ::safe_browsing::_ClientIncidentReport_DownloadDetails_default_instance_);
+}
+inline const ::safe_browsing::ClientIncidentReport_DownloadDetails& DownloadMetadata::download() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.DownloadMetadata.download)
+  return _internal_download();
+}
+inline void DownloadMetadata::unsafe_arena_set_allocated_download(
+    ::safe_browsing::ClientIncidentReport_DownloadDetails* download) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.download_);
+  }
+  _impl_.download_ = download;
+  if (download) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.DownloadMetadata.download)
+}
+inline ::safe_browsing::ClientIncidentReport_DownloadDetails* DownloadMetadata::release_download() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* temp = _impl_.download_;
+  _impl_.download_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_DownloadDetails* DownloadMetadata::unsafe_arena_release_download() {
+  // @@protoc_insertion_point(field_release:safe_browsing.DownloadMetadata.download)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* temp = _impl_.download_;
+  _impl_.download_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientIncidentReport_DownloadDetails* DownloadMetadata::_internal_mutable_download() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.download_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_DownloadDetails>(GetArenaForAllocation());
+    _impl_.download_ = p;
+  }
+  return _impl_.download_;
+}
+inline ::safe_browsing::ClientIncidentReport_DownloadDetails* DownloadMetadata::mutable_download() {
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* _msg = _internal_mutable_download();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.DownloadMetadata.download)
+  return _msg;
+}
+inline void DownloadMetadata::set_allocated_download(::safe_browsing::ClientIncidentReport_DownloadDetails* download) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.download_;
+  }
+  if (download) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(download);
+    if (message_arena != submessage_arena) {
+      download = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, download, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.download_ = download;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.DownloadMetadata.download)
+}
+
+// -------------------------------------------------------------------
+
+// ClientSafeBrowsingReportRequest_HTTPHeader
+
+// required bytes name = 1;
+inline bool ClientSafeBrowsingReportRequest_HTTPHeader::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPHeader::has_name() const {
+  return _internal_has_name();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPHeader::name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_HTTPHeader::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name)
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPHeader::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPHeader::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPHeader::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPHeader::release_name() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name)
+}
+
+// optional bytes value = 2;
+inline bool ClientSafeBrowsingReportRequest_HTTPHeader::_internal_has_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPHeader::has_value() const {
+  return _internal_has_value();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::clear_value() {
+  _impl_.value_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPHeader::value() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value)
+  return _internal_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_HTTPHeader::set_value(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value)
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPHeader::mutable_value() {
+  std::string* _s = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPHeader::_internal_value() const {
+  return _impl_.value_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::_internal_set_value(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPHeader::_internal_mutable_value() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPHeader::release_value() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value)
+  if (!_internal_has_value()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.value_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.value_.IsDefault()) {
+    _impl_.value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_allocated_value(std::string* value) {
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.value_.IsDefault()) {
+    _impl_.value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value)
+}
+
+// -------------------------------------------------------------------
+
+// ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine
+
+// optional bytes verb = 1;
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_has_verb() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::has_verb() const {
+  return _internal_has_verb();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::clear_verb() {
+  _impl_.verb_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::verb() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb)
+  return _internal_verb();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_verb(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.verb_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb)
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::mutable_verb() {
+  std::string* _s = _internal_mutable_verb();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_verb() const {
+  return _impl_.verb_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_set_verb(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.verb_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_mutable_verb() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.verb_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::release_verb() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb)
+  if (!_internal_has_verb()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.verb_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.verb_.IsDefault()) {
+    _impl_.verb_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_allocated_verb(std::string* verb) {
+  if (verb != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.verb_.SetAllocated(verb, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.verb_.IsDefault()) {
+    _impl_.verb_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb)
+}
+
+// optional bytes uri = 2;
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_has_uri() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::has_uri() const {
+  return _internal_has_uri();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::clear_uri() {
+  _impl_.uri_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::uri() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri)
+  return _internal_uri();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_uri(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.uri_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri)
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::mutable_uri() {
+  std::string* _s = _internal_mutable_uri();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_uri() const {
+  return _impl_.uri_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_set_uri(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.uri_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_mutable_uri() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.uri_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::release_uri() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri)
+  if (!_internal_has_uri()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.uri_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.uri_.IsDefault()) {
+    _impl_.uri_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_allocated_uri(std::string* uri) {
+  if (uri != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.uri_.SetAllocated(uri, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.uri_.IsDefault()) {
+    _impl_.uri_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri)
+}
+
+// optional bytes version = 3;
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_has_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::has_version() const {
+  return _internal_has_version();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::clear_version() {
+  _impl_.version_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version)
+  return _internal_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_version(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.version_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version)
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::mutable_version() {
+  std::string* _s = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_version() const {
+  return _impl_.version_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_set_version(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.version_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_mutable_version() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.version_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::release_version() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version)
+  if (!_internal_has_version()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.version_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_.IsDefault()) {
+    _impl_.version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_allocated_version(std::string* version) {
+  if (version != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_.IsDefault()) {
+    _impl_.version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version)
+}
+
+// -------------------------------------------------------------------
+
+// ClientSafeBrowsingReportRequest_HTTPRequest
+
+// optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine firstline = 1;
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest::_internal_has_firstline() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.firstline_ != nullptr);
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest::has_firstline() const {
+  return _internal_has_firstline();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_firstline() {
+  if (_impl_.firstline_ != nullptr) _impl_.firstline_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& ClientSafeBrowsingReportRequest_HTTPRequest::_internal_firstline() const {
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* p = _impl_.firstline_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine&>(
+      ::safe_browsing::_ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_default_instance_);
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& ClientSafeBrowsingReportRequest_HTTPRequest::firstline() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.firstline)
+  return _internal_firstline();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::unsafe_arena_set_allocated_firstline(
+    ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* firstline) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.firstline_);
+  }
+  _impl_.firstline_ = firstline;
+  if (firstline) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.firstline)
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* ClientSafeBrowsingReportRequest_HTTPRequest::release_firstline() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* temp = _impl_.firstline_;
+  _impl_.firstline_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* ClientSafeBrowsingReportRequest_HTTPRequest::unsafe_arena_release_firstline() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.firstline)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* temp = _impl_.firstline_;
+  _impl_.firstline_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* ClientSafeBrowsingReportRequest_HTTPRequest::_internal_mutable_firstline() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.firstline_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine>(GetArenaForAllocation());
+    _impl_.firstline_ = p;
+  }
+  return _impl_.firstline_;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* ClientSafeBrowsingReportRequest_HTTPRequest::mutable_firstline() {
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* _msg = _internal_mutable_firstline();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.firstline)
+  return _msg;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_allocated_firstline(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* firstline) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.firstline_;
+  }
+  if (firstline) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(firstline);
+    if (message_arena != submessage_arena) {
+      firstline = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, firstline, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.firstline_ = firstline;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.firstline)
+}
+
+// repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+inline int ClientSafeBrowsingReportRequest_HTTPRequest::_internal_headers_size() const {
+  return _impl_.headers_.size();
+}
+inline int ClientSafeBrowsingReportRequest_HTTPRequest::headers_size() const {
+  return _internal_headers_size();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_headers() {
+  _impl_.headers_.Clear();
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPRequest::mutable_headers(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.headers)
+  return _impl_.headers_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >*
+ClientSafeBrowsingReportRequest_HTTPRequest::mutable_headers() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.headers)
+  return &_impl_.headers_;
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& ClientSafeBrowsingReportRequest_HTTPRequest::_internal_headers(int index) const {
+  return _impl_.headers_.Get(index);
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& ClientSafeBrowsingReportRequest_HTTPRequest::headers(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.headers)
+  return _internal_headers(index);
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPRequest::_internal_add_headers() {
+  return _impl_.headers_.Add();
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPRequest::add_headers() {
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* _add = _internal_add_headers();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.headers)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >&
+ClientSafeBrowsingReportRequest_HTTPRequest::headers() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.headers)
+  return _impl_.headers_;
+}
+
+// optional bytes body = 3;
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest::_internal_has_body() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest::has_body() const {
+  return _internal_has_body();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_body() {
+  _impl_.body_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest::body() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body)
+  return _internal_body();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_HTTPRequest::set_body(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.body_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body)
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest::mutable_body() {
+  std::string* _s = _internal_mutable_body();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest::_internal_body() const {
+  return _impl_.body_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::_internal_set_body(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.body_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest::_internal_mutable_body() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.body_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest::release_body() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body)
+  if (!_internal_has_body()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.body_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.body_.IsDefault()) {
+    _impl_.body_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_allocated_body(std::string* body) {
+  if (body != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.body_.SetAllocated(body, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.body_.IsDefault()) {
+    _impl_.body_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body)
+}
+
+// optional bytes bodydigest = 4;
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest::_internal_has_bodydigest() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest::has_bodydigest() const {
+  return _internal_has_bodydigest();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_bodydigest() {
+  _impl_.bodydigest_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest::bodydigest() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest)
+  return _internal_bodydigest();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_HTTPRequest::set_bodydigest(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.bodydigest_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest)
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest::mutable_bodydigest() {
+  std::string* _s = _internal_mutable_bodydigest();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest::_internal_bodydigest() const {
+  return _impl_.bodydigest_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::_internal_set_bodydigest(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.bodydigest_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest::_internal_mutable_bodydigest() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.bodydigest_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest::release_bodydigest() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest)
+  if (!_internal_has_bodydigest()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.bodydigest_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.bodydigest_.IsDefault()) {
+    _impl_.bodydigest_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_allocated_bodydigest(std::string* bodydigest) {
+  if (bodydigest != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.bodydigest_.SetAllocated(bodydigest, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.bodydigest_.IsDefault()) {
+    _impl_.bodydigest_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest)
+}
+
+// optional int32 bodylength = 5;
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest::_internal_has_bodylength() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest::has_bodylength() const {
+  return _internal_has_bodylength();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_bodylength() {
+  _impl_.bodylength_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int32_t ClientSafeBrowsingReportRequest_HTTPRequest::_internal_bodylength() const {
+  return _impl_.bodylength_;
+}
+inline int32_t ClientSafeBrowsingReportRequest_HTTPRequest::bodylength() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodylength)
+  return _internal_bodylength();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::_internal_set_bodylength(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.bodylength_ = value;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_bodylength(int32_t value) {
+  _internal_set_bodylength(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodylength)
+}
+
+// -------------------------------------------------------------------
+
+// ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine
+
+// optional int32 code = 1;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_has_code() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::has_code() const {
+  return _internal_has_code();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::clear_code() {
+  _impl_.code_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_code() const {
+  return _impl_.code_;
+}
+inline int32_t ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::code() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.code)
+  return _internal_code();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_set_code(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.code_ = value;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_code(int32_t value) {
+  _internal_set_code(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.code)
+}
+
+// optional bytes message = 2;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_has_message() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::has_message() const {
+  return _internal_has_message();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::clear_message() {
+  _impl_.message_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::message() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.message)
+  return _internal_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_message(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.message_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.message)
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::mutable_message() {
+  std::string* _s = _internal_mutable_message();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.message)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_message() const {
+  return _impl_.message_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_set_message(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.message_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_mutable_message() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.message_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::release_message() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.message)
+  if (!_internal_has_message()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.message_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.message_.IsDefault()) {
+    _impl_.message_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_allocated_message(std::string* message) {
+  if (message != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.message_.SetAllocated(message, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.message_.IsDefault()) {
+    _impl_.message_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.message)
+}
+
+// optional bytes version = 3;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_has_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::has_version() const {
+  return _internal_has_version();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::clear_version() {
+  _impl_.version_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version)
+  return _internal_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_version(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.version_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version)
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::mutable_version() {
+  std::string* _s = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_version() const {
+  return _impl_.version_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_set_version(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.version_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_mutable_version() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.version_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::release_version() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version)
+  if (!_internal_has_version()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.version_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_.IsDefault()) {
+    _impl_.version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_allocated_version(std::string* version) {
+  if (version != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_.IsDefault()) {
+    _impl_.version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version)
+}
+
+// -------------------------------------------------------------------
+
+// ClientSafeBrowsingReportRequest_HTTPResponse
+
+// optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine firstline = 1;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::_internal_has_firstline() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.firstline_ != nullptr);
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::has_firstline() const {
+  return _internal_has_firstline();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_firstline() {
+  if (_impl_.firstline_ != nullptr) _impl_.firstline_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& ClientSafeBrowsingReportRequest_HTTPResponse::_internal_firstline() const {
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* p = _impl_.firstline_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine&>(
+      ::safe_browsing::_ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_default_instance_);
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& ClientSafeBrowsingReportRequest_HTTPResponse::firstline() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.firstline)
+  return _internal_firstline();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::unsafe_arena_set_allocated_firstline(
+    ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* firstline) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.firstline_);
+  }
+  _impl_.firstline_ = firstline;
+  if (firstline) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.firstline)
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* ClientSafeBrowsingReportRequest_HTTPResponse::release_firstline() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* temp = _impl_.firstline_;
+  _impl_.firstline_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* ClientSafeBrowsingReportRequest_HTTPResponse::unsafe_arena_release_firstline() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.firstline)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* temp = _impl_.firstline_;
+  _impl_.firstline_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* ClientSafeBrowsingReportRequest_HTTPResponse::_internal_mutable_firstline() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.firstline_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine>(GetArenaForAllocation());
+    _impl_.firstline_ = p;
+  }
+  return _impl_.firstline_;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_firstline() {
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* _msg = _internal_mutable_firstline();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.firstline)
+  return _msg;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_allocated_firstline(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* firstline) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.firstline_;
+  }
+  if (firstline) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(firstline);
+    if (message_arena != submessage_arena) {
+      firstline = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, firstline, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.firstline_ = firstline;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.firstline)
+}
+
+// repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+inline int ClientSafeBrowsingReportRequest_HTTPResponse::_internal_headers_size() const {
+  return _impl_.headers_.size();
+}
+inline int ClientSafeBrowsingReportRequest_HTTPResponse::headers_size() const {
+  return _internal_headers_size();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_headers() {
+  _impl_.headers_.Clear();
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_headers(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.headers)
+  return _impl_.headers_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >*
+ClientSafeBrowsingReportRequest_HTTPResponse::mutable_headers() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.headers)
+  return &_impl_.headers_;
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& ClientSafeBrowsingReportRequest_HTTPResponse::_internal_headers(int index) const {
+  return _impl_.headers_.Get(index);
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& ClientSafeBrowsingReportRequest_HTTPResponse::headers(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.headers)
+  return _internal_headers(index);
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPResponse::_internal_add_headers() {
+  return _impl_.headers_.Add();
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPResponse::add_headers() {
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* _add = _internal_add_headers();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.headers)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >&
+ClientSafeBrowsingReportRequest_HTTPResponse::headers() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.headers)
+  return _impl_.headers_;
+}
+
+// optional bytes body = 3;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::_internal_has_body() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::has_body() const {
+  return _internal_has_body();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_body() {
+  _impl_.body_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse::body() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body)
+  return _internal_body();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_HTTPResponse::set_body(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.body_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body)
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_body() {
+  std::string* _s = _internal_mutable_body();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse::_internal_body() const {
+  return _impl_.body_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::_internal_set_body(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.body_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::_internal_mutable_body() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.body_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::release_body() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body)
+  if (!_internal_has_body()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.body_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.body_.IsDefault()) {
+    _impl_.body_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_allocated_body(std::string* body) {
+  if (body != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.body_.SetAllocated(body, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.body_.IsDefault()) {
+    _impl_.body_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body)
+}
+
+// optional bytes bodydigest = 4;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::_internal_has_bodydigest() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::has_bodydigest() const {
+  return _internal_has_bodydigest();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_bodydigest() {
+  _impl_.bodydigest_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse::bodydigest() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest)
+  return _internal_bodydigest();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_HTTPResponse::set_bodydigest(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.bodydigest_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest)
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_bodydigest() {
+  std::string* _s = _internal_mutable_bodydigest();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse::_internal_bodydigest() const {
+  return _impl_.bodydigest_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::_internal_set_bodydigest(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.bodydigest_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::_internal_mutable_bodydigest() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.bodydigest_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::release_bodydigest() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest)
+  if (!_internal_has_bodydigest()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.bodydigest_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.bodydigest_.IsDefault()) {
+    _impl_.bodydigest_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_allocated_bodydigest(std::string* bodydigest) {
+  if (bodydigest != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.bodydigest_.SetAllocated(bodydigest, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.bodydigest_.IsDefault()) {
+    _impl_.bodydigest_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest)
+}
+
+// optional int32 bodylength = 5;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::_internal_has_bodylength() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::has_bodylength() const {
+  return _internal_has_bodylength();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_bodylength() {
+  _impl_.bodylength_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline int32_t ClientSafeBrowsingReportRequest_HTTPResponse::_internal_bodylength() const {
+  return _impl_.bodylength_;
+}
+inline int32_t ClientSafeBrowsingReportRequest_HTTPResponse::bodylength() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodylength)
+  return _internal_bodylength();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::_internal_set_bodylength(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.bodylength_ = value;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_bodylength(int32_t value) {
+  _internal_set_bodylength(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodylength)
+}
+
+// optional bytes remote_ip = 6;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::_internal_has_remote_ip() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::has_remote_ip() const {
+  return _internal_has_remote_ip();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_remote_ip() {
+  _impl_.remote_ip_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse::remote_ip() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip)
+  return _internal_remote_ip();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_HTTPResponse::set_remote_ip(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.remote_ip_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip)
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_remote_ip() {
+  std::string* _s = _internal_mutable_remote_ip();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse::_internal_remote_ip() const {
+  return _impl_.remote_ip_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::_internal_set_remote_ip(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.remote_ip_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::_internal_mutable_remote_ip() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.remote_ip_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::release_remote_ip() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip)
+  if (!_internal_has_remote_ip()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.remote_ip_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.remote_ip_.IsDefault()) {
+    _impl_.remote_ip_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_allocated_remote_ip(std::string* remote_ip) {
+  if (remote_ip != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.remote_ip_.SetAllocated(remote_ip, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.remote_ip_.IsDefault()) {
+    _impl_.remote_ip_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip)
+}
+
+// -------------------------------------------------------------------
+
+// ClientSafeBrowsingReportRequest_Resource
+
+// required int32 id = 1;
+inline bool ClientSafeBrowsingReportRequest_Resource::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_Resource::has_id() const {
+  return _internal_has_id();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_id() {
+  _impl_.id_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline int32_t ClientSafeBrowsingReportRequest_Resource::_internal_id() const {
+  return _impl_.id_;
+}
+inline int32_t ClientSafeBrowsingReportRequest_Resource::id() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.id)
+  return _internal_id();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::_internal_set_id(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.id_ = value;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_id(int32_t value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.Resource.id)
+}
+
+// optional string url = 2;
+inline bool ClientSafeBrowsingReportRequest_Resource::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_Resource::has_url() const {
+  return _internal_has_url();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_Resource::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_Resource::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url)
+}
+inline std::string* ClientSafeBrowsingReportRequest_Resource::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_Resource::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_Resource::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_Resource::release_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url)
+}
+
+// optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest request = 3;
+inline bool ClientSafeBrowsingReportRequest_Resource::_internal_has_request() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.request_ != nullptr);
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_Resource::has_request() const {
+  return _internal_has_request();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_request() {
+  if (_impl_.request_ != nullptr) _impl_.request_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest& ClientSafeBrowsingReportRequest_Resource::_internal_request() const {
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* p = _impl_.request_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest&>(
+      ::safe_browsing::_ClientSafeBrowsingReportRequest_HTTPRequest_default_instance_);
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest& ClientSafeBrowsingReportRequest_Resource::request() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.request)
+  return _internal_request();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::unsafe_arena_set_allocated_request(
+    ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* request) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.request_);
+  }
+  _impl_.request_ = request;
+  if (request) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.Resource.request)
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* ClientSafeBrowsingReportRequest_Resource::release_request() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* temp = _impl_.request_;
+  _impl_.request_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* ClientSafeBrowsingReportRequest_Resource::unsafe_arena_release_request() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.Resource.request)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* temp = _impl_.request_;
+  _impl_.request_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* ClientSafeBrowsingReportRequest_Resource::_internal_mutable_request() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.request_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest>(GetArenaForAllocation());
+    _impl_.request_ = p;
+  }
+  return _impl_.request_;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* ClientSafeBrowsingReportRequest_Resource::mutable_request() {
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* _msg = _internal_mutable_request();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.Resource.request)
+  return _msg;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_allocated_request(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* request) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.request_;
+  }
+  if (request) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(request);
+    if (message_arena != submessage_arena) {
+      request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, request, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.request_ = request;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.Resource.request)
+}
+
+// optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse response = 4;
+inline bool ClientSafeBrowsingReportRequest_Resource::_internal_has_response() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.response_ != nullptr);
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_Resource::has_response() const {
+  return _internal_has_response();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_response() {
+  if (_impl_.response_ != nullptr) _impl_.response_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse& ClientSafeBrowsingReportRequest_Resource::_internal_response() const {
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* p = _impl_.response_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse&>(
+      ::safe_browsing::_ClientSafeBrowsingReportRequest_HTTPResponse_default_instance_);
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse& ClientSafeBrowsingReportRequest_Resource::response() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.response)
+  return _internal_response();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::unsafe_arena_set_allocated_response(
+    ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* response) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.response_);
+  }
+  _impl_.response_ = response;
+  if (response) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.Resource.response)
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* ClientSafeBrowsingReportRequest_Resource::release_response() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* temp = _impl_.response_;
+  _impl_.response_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* ClientSafeBrowsingReportRequest_Resource::unsafe_arena_release_response() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.Resource.response)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* temp = _impl_.response_;
+  _impl_.response_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* ClientSafeBrowsingReportRequest_Resource::_internal_mutable_response() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.response_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse>(GetArenaForAllocation());
+    _impl_.response_ = p;
+  }
+  return _impl_.response_;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* ClientSafeBrowsingReportRequest_Resource::mutable_response() {
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* _msg = _internal_mutable_response();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.Resource.response)
+  return _msg;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_allocated_response(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* response) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.response_;
+  }
+  if (response) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(response);
+    if (message_arena != submessage_arena) {
+      response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, response, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.response_ = response;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.Resource.response)
+}
+
+// optional int32 parent_id = 5;
+inline bool ClientSafeBrowsingReportRequest_Resource::_internal_has_parent_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_Resource::has_parent_id() const {
+  return _internal_has_parent_id();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_parent_id() {
+  _impl_.parent_id_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline int32_t ClientSafeBrowsingReportRequest_Resource::_internal_parent_id() const {
+  return _impl_.parent_id_;
+}
+inline int32_t ClientSafeBrowsingReportRequest_Resource::parent_id() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.parent_id)
+  return _internal_parent_id();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::_internal_set_parent_id(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.parent_id_ = value;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_parent_id(int32_t value) {
+  _internal_set_parent_id(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.Resource.parent_id)
+}
+
+// repeated int32 child_ids = 6;
+inline int ClientSafeBrowsingReportRequest_Resource::_internal_child_ids_size() const {
+  return _impl_.child_ids_.size();
+}
+inline int ClientSafeBrowsingReportRequest_Resource::child_ids_size() const {
+  return _internal_child_ids_size();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_child_ids() {
+  _impl_.child_ids_.Clear();
+}
+inline int32_t ClientSafeBrowsingReportRequest_Resource::_internal_child_ids(int index) const {
+  return _impl_.child_ids_.Get(index);
+}
+inline int32_t ClientSafeBrowsingReportRequest_Resource::child_ids(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.child_ids)
+  return _internal_child_ids(index);
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_child_ids(int index, int32_t value) {
+  _impl_.child_ids_.Set(index, value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.Resource.child_ids)
+}
+inline void ClientSafeBrowsingReportRequest_Resource::_internal_add_child_ids(int32_t value) {
+  _impl_.child_ids_.Add(value);
+}
+inline void ClientSafeBrowsingReportRequest_Resource::add_child_ids(int32_t value) {
+  _internal_add_child_ids(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.Resource.child_ids)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+ClientSafeBrowsingReportRequest_Resource::_internal_child_ids() const {
+  return _impl_.child_ids_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+ClientSafeBrowsingReportRequest_Resource::child_ids() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientSafeBrowsingReportRequest.Resource.child_ids)
+  return _internal_child_ids();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+ClientSafeBrowsingReportRequest_Resource::_internal_mutable_child_ids() {
+  return &_impl_.child_ids_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+ClientSafeBrowsingReportRequest_Resource::mutable_child_ids() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientSafeBrowsingReportRequest.Resource.child_ids)
+  return _internal_mutable_child_ids();
+}
+
+// optional string tag_name = 7;
+inline bool ClientSafeBrowsingReportRequest_Resource::_internal_has_tag_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_Resource::has_tag_name() const {
+  return _internal_has_tag_name();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_tag_name() {
+  _impl_.tag_name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_Resource::tag_name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name)
+  return _internal_tag_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_Resource::set_tag_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.tag_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name)
+}
+inline std::string* ClientSafeBrowsingReportRequest_Resource::mutable_tag_name() {
+  std::string* _s = _internal_mutable_tag_name();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_Resource::_internal_tag_name() const {
+  return _impl_.tag_name_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::_internal_set_tag_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.tag_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_Resource::_internal_mutable_tag_name() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.tag_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_Resource::release_tag_name() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name)
+  if (!_internal_has_tag_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.tag_name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.tag_name_.IsDefault()) {
+    _impl_.tag_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_allocated_tag_name(std::string* tag_name) {
+  if (tag_name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.tag_name_.SetAllocated(tag_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.tag_name_.IsDefault()) {
+    _impl_.tag_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name)
+}
+
+// -------------------------------------------------------------------
+
+// ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties
+
+// optional string client_version = 1;
+inline bool ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_has_client_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::has_client_version() const {
+  return _internal_has_client_version();
+}
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::clear_client_version() {
+  _impl_.client_version_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::client_version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.client_version)
+  return _internal_client_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::set_client_version(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.client_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.client_version)
+}
+inline std::string* ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::mutable_client_version() {
+  std::string* _s = _internal_mutable_client_version();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.client_version)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_client_version() const {
+  return _impl_.client_version_.Get();
+}
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_set_client_version(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.client_version_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_mutable_client_version() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.client_version_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::release_client_version() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.client_version)
+  if (!_internal_has_client_version()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.client_version_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.client_version_.IsDefault()) {
+    _impl_.client_version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::set_allocated_client_version(std::string* client_version) {
+  if (client_version != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.client_version_.SetAllocated(client_version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.client_version_.IsDefault()) {
+    _impl_.client_version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.client_version)
+}
+
+// optional int64 google_play_services_version = 2;
+inline bool ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_has_google_play_services_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::has_google_play_services_version() const {
+  return _internal_has_google_play_services_version();
+}
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::clear_google_play_services_version() {
+  _impl_.google_play_services_version_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int64_t ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_google_play_services_version() const {
+  return _impl_.google_play_services_version_;
+}
+inline int64_t ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::google_play_services_version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.google_play_services_version)
+  return _internal_google_play_services_version();
+}
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_set_google_play_services_version(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.google_play_services_version_ = value;
+}
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::set_google_play_services_version(int64_t value) {
+  _internal_set_google_play_services_version(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.google_play_services_version)
+}
+
+// optional bool is_instant_apps = 3;
+inline bool ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_has_is_instant_apps() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::has_is_instant_apps() const {
+  return _internal_has_is_instant_apps();
+}
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::clear_is_instant_apps() {
+  _impl_.is_instant_apps_ = false;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline bool ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_is_instant_apps() const {
+  return _impl_.is_instant_apps_;
+}
+inline bool ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::is_instant_apps() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.is_instant_apps)
+  return _internal_is_instant_apps();
+}
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_set_is_instant_apps(bool value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.is_instant_apps_ = value;
+}
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::set_is_instant_apps(bool value) {
+  _internal_set_is_instant_apps(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.is_instant_apps)
+}
+
+// optional .safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingUrlApiType url_api_type = 4;
+inline bool ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_has_url_api_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::has_url_api_type() const {
+  return _internal_has_url_api_type();
+}
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::clear_url_api_type() {
+  _impl_.url_api_type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_url_api_type() const {
+  return static_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType >(_impl_.url_api_type_);
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::url_api_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.url_api_type)
+  return _internal_url_api_type();
+}
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_set_url_api_type(::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType value) {
+  assert(::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.url_api_type_ = value;
+}
+inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::set_url_api_type(::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType value) {
+  _internal_set_url_api_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.url_api_type)
+}
+
+// -------------------------------------------------------------------
+
+// ClientSafeBrowsingReportRequest
+
+// optional .safe_browsing.ClientSafeBrowsingReportRequest.ReportType type = 10;
+inline bool ClientSafeBrowsingReportRequest::_internal_has_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest::has_type() const {
+  return _internal_has_type();
+}
+inline void ClientSafeBrowsingReportRequest::clear_type() {
+  _impl_.type_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::_internal_type() const {
+  return static_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_ReportType >(_impl_.type_);
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.type)
+  return _internal_type();
+}
+inline void ClientSafeBrowsingReportRequest::_internal_set_type(::safe_browsing::ClientSafeBrowsingReportRequest_ReportType value) {
+  assert(::safe_browsing::ClientSafeBrowsingReportRequest_ReportType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.type_ = value;
+}
+inline void ClientSafeBrowsingReportRequest::set_type(::safe_browsing::ClientSafeBrowsingReportRequest_ReportType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.type)
+}
+
+// optional .safe_browsing.ClientDownloadResponse.Verdict download_verdict = 11;
+inline bool ClientSafeBrowsingReportRequest::_internal_has_download_verdict() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest::has_download_verdict() const {
+  return _internal_has_download_verdict();
+}
+inline void ClientSafeBrowsingReportRequest::clear_download_verdict() {
+  _impl_.download_verdict_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline ::safe_browsing::ClientDownloadResponse_Verdict ClientSafeBrowsingReportRequest::_internal_download_verdict() const {
+  return static_cast< ::safe_browsing::ClientDownloadResponse_Verdict >(_impl_.download_verdict_);
+}
+inline ::safe_browsing::ClientDownloadResponse_Verdict ClientSafeBrowsingReportRequest::download_verdict() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.download_verdict)
+  return _internal_download_verdict();
+}
+inline void ClientSafeBrowsingReportRequest::_internal_set_download_verdict(::safe_browsing::ClientDownloadResponse_Verdict value) {
+  assert(::safe_browsing::ClientDownloadResponse_Verdict_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.download_verdict_ = value;
+}
+inline void ClientSafeBrowsingReportRequest::set_download_verdict(::safe_browsing::ClientDownloadResponse_Verdict value) {
+  _internal_set_download_verdict(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.download_verdict)
+}
+
+// optional string url = 1;
+inline bool ClientSafeBrowsingReportRequest::_internal_has_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest::has_url() const {
+  return _internal_has_url();
+}
+inline void ClientSafeBrowsingReportRequest::clear_url() {
+  _impl_.url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.url)
+  return _internal_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest::set_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.url)
+}
+inline std::string* ClientSafeBrowsingReportRequest::mutable_url() {
+  std::string* _s = _internal_mutable_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.url)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest::_internal_url() const {
+  return _impl_.url_.Get();
+}
+inline void ClientSafeBrowsingReportRequest::_internal_set_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest::_internal_mutable_url() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest::release_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.url)
+  if (!_internal_has_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest::set_allocated_url(std::string* url) {
+  if (url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.url_.SetAllocated(url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.url_.IsDefault()) {
+    _impl_.url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.url)
+}
+
+// optional string page_url = 2;
+inline bool ClientSafeBrowsingReportRequest::_internal_has_page_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest::has_page_url() const {
+  return _internal_has_page_url();
+}
+inline void ClientSafeBrowsingReportRequest::clear_page_url() {
+  _impl_.page_url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest::page_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.page_url)
+  return _internal_page_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest::set_page_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.page_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.page_url)
+}
+inline std::string* ClientSafeBrowsingReportRequest::mutable_page_url() {
+  std::string* _s = _internal_mutable_page_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.page_url)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest::_internal_page_url() const {
+  return _impl_.page_url_.Get();
+}
+inline void ClientSafeBrowsingReportRequest::_internal_set_page_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.page_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest::_internal_mutable_page_url() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.page_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest::release_page_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.page_url)
+  if (!_internal_has_page_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.page_url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.page_url_.IsDefault()) {
+    _impl_.page_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest::set_allocated_page_url(std::string* page_url) {
+  if (page_url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.page_url_.SetAllocated(page_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.page_url_.IsDefault()) {
+    _impl_.page_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.page_url)
+}
+
+// optional string referrer_url = 3;
+inline bool ClientSafeBrowsingReportRequest::_internal_has_referrer_url() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest::has_referrer_url() const {
+  return _internal_has_referrer_url();
+}
+inline void ClientSafeBrowsingReportRequest::clear_referrer_url() {
+  _impl_.referrer_url_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest::referrer_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url)
+  return _internal_referrer_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest::set_referrer_url(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.referrer_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url)
+}
+inline std::string* ClientSafeBrowsingReportRequest::mutable_referrer_url() {
+  std::string* _s = _internal_mutable_referrer_url();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest::_internal_referrer_url() const {
+  return _impl_.referrer_url_.Get();
+}
+inline void ClientSafeBrowsingReportRequest::_internal_set_referrer_url(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.referrer_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest::_internal_mutable_referrer_url() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.referrer_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest::release_referrer_url() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url)
+  if (!_internal_has_referrer_url()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.referrer_url_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_url_.IsDefault()) {
+    _impl_.referrer_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest::set_allocated_referrer_url(std::string* referrer_url) {
+  if (referrer_url != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.referrer_url_.SetAllocated(referrer_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.referrer_url_.IsDefault()) {
+    _impl_.referrer_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url)
+}
+
+// repeated .safe_browsing.ClientSafeBrowsingReportRequest.Resource resources = 4;
+inline int ClientSafeBrowsingReportRequest::_internal_resources_size() const {
+  return _impl_.resources_.size();
+}
+inline int ClientSafeBrowsingReportRequest::resources_size() const {
+  return _internal_resources_size();
+}
+inline void ClientSafeBrowsingReportRequest::clear_resources() {
+  _impl_.resources_.Clear();
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* ClientSafeBrowsingReportRequest::mutable_resources(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.resources)
+  return _impl_.resources_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource >*
+ClientSafeBrowsingReportRequest::mutable_resources() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientSafeBrowsingReportRequest.resources)
+  return &_impl_.resources_;
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_Resource& ClientSafeBrowsingReportRequest::_internal_resources(int index) const {
+  return _impl_.resources_.Get(index);
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_Resource& ClientSafeBrowsingReportRequest::resources(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.resources)
+  return _internal_resources(index);
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* ClientSafeBrowsingReportRequest::_internal_add_resources() {
+  return _impl_.resources_.Add();
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* ClientSafeBrowsingReportRequest::add_resources() {
+  ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* _add = _internal_add_resources();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.resources)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource >&
+ClientSafeBrowsingReportRequest::resources() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientSafeBrowsingReportRequest.resources)
+  return _impl_.resources_;
+}
+
+// repeated .safe_browsing.HTMLElement dom = 16;
+inline int ClientSafeBrowsingReportRequest::_internal_dom_size() const {
+  return _impl_.dom_.size();
+}
+inline int ClientSafeBrowsingReportRequest::dom_size() const {
+  return _internal_dom_size();
+}
+inline void ClientSafeBrowsingReportRequest::clear_dom() {
+  _impl_.dom_.Clear();
+}
+inline ::safe_browsing::HTMLElement* ClientSafeBrowsingReportRequest::mutable_dom(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.dom)
+  return _impl_.dom_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::HTMLElement >*
+ClientSafeBrowsingReportRequest::mutable_dom() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientSafeBrowsingReportRequest.dom)
+  return &_impl_.dom_;
+}
+inline const ::safe_browsing::HTMLElement& ClientSafeBrowsingReportRequest::_internal_dom(int index) const {
+  return _impl_.dom_.Get(index);
+}
+inline const ::safe_browsing::HTMLElement& ClientSafeBrowsingReportRequest::dom(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.dom)
+  return _internal_dom(index);
+}
+inline ::safe_browsing::HTMLElement* ClientSafeBrowsingReportRequest::_internal_add_dom() {
+  return _impl_.dom_.Add();
+}
+inline ::safe_browsing::HTMLElement* ClientSafeBrowsingReportRequest::add_dom() {
+  ::safe_browsing::HTMLElement* _add = _internal_add_dom();
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.dom)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::HTMLElement >&
+ClientSafeBrowsingReportRequest::dom() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientSafeBrowsingReportRequest.dom)
+  return _impl_.dom_;
+}
+
+// optional bool complete = 5;
+inline bool ClientSafeBrowsingReportRequest::_internal_has_complete() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest::has_complete() const {
+  return _internal_has_complete();
+}
+inline void ClientSafeBrowsingReportRequest::clear_complete() {
+  _impl_.complete_ = false;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline bool ClientSafeBrowsingReportRequest::_internal_complete() const {
+  return _impl_.complete_;
+}
+inline bool ClientSafeBrowsingReportRequest::complete() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.complete)
+  return _internal_complete();
+}
+inline void ClientSafeBrowsingReportRequest::_internal_set_complete(bool value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.complete_ = value;
+}
+inline void ClientSafeBrowsingReportRequest::set_complete(bool value) {
+  _internal_set_complete(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.complete)
+}
+
+// repeated string client_asn = 6;
+inline int ClientSafeBrowsingReportRequest::_internal_client_asn_size() const {
+  return _impl_.client_asn_.size();
+}
+inline int ClientSafeBrowsingReportRequest::client_asn_size() const {
+  return _internal_client_asn_size();
+}
+inline void ClientSafeBrowsingReportRequest::clear_client_asn() {
+  _impl_.client_asn_.Clear();
+}
+inline std::string* ClientSafeBrowsingReportRequest::add_client_asn() {
+  std::string* _s = _internal_add_client_asn();
+  // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest::_internal_client_asn(int index) const {
+  return _impl_.client_asn_.Get(index);
+}
+inline const std::string& ClientSafeBrowsingReportRequest::client_asn(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+  return _internal_client_asn(index);
+}
+inline std::string* ClientSafeBrowsingReportRequest::mutable_client_asn(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+  return _impl_.client_asn_.Mutable(index);
+}
+inline void ClientSafeBrowsingReportRequest::set_client_asn(int index, const std::string& value) {
+  _impl_.client_asn_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+}
+inline void ClientSafeBrowsingReportRequest::set_client_asn(int index, std::string&& value) {
+  _impl_.client_asn_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+}
+inline void ClientSafeBrowsingReportRequest::set_client_asn(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.client_asn_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+}
+inline void ClientSafeBrowsingReportRequest::set_client_asn(int index, const char* value, size_t size) {
+  _impl_.client_asn_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+}
+inline std::string* ClientSafeBrowsingReportRequest::_internal_add_client_asn() {
+  return _impl_.client_asn_.Add();
+}
+inline void ClientSafeBrowsingReportRequest::add_client_asn(const std::string& value) {
+  _impl_.client_asn_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+}
+inline void ClientSafeBrowsingReportRequest::add_client_asn(std::string&& value) {
+  _impl_.client_asn_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+}
+inline void ClientSafeBrowsingReportRequest::add_client_asn(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.client_asn_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+}
+inline void ClientSafeBrowsingReportRequest::add_client_asn(const char* value, size_t size) {
+  _impl_.client_asn_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ClientSafeBrowsingReportRequest::client_asn() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+  return _impl_.client_asn_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ClientSafeBrowsingReportRequest::mutable_client_asn() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+  return &_impl_.client_asn_;
+}
+
+// optional string client_country = 7;
+inline bool ClientSafeBrowsingReportRequest::_internal_has_client_country() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest::has_client_country() const {
+  return _internal_has_client_country();
+}
+inline void ClientSafeBrowsingReportRequest::clear_client_country() {
+  _impl_.client_country_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest::client_country() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.client_country)
+  return _internal_client_country();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest::set_client_country(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.client_country_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.client_country)
+}
+inline std::string* ClientSafeBrowsingReportRequest::mutable_client_country() {
+  std::string* _s = _internal_mutable_client_country();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.client_country)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest::_internal_client_country() const {
+  return _impl_.client_country_.Get();
+}
+inline void ClientSafeBrowsingReportRequest::_internal_set_client_country(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.client_country_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest::_internal_mutable_client_country() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.client_country_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest::release_client_country() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.client_country)
+  if (!_internal_has_client_country()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.client_country_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.client_country_.IsDefault()) {
+    _impl_.client_country_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest::set_allocated_client_country(std::string* client_country) {
+  if (client_country != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.client_country_.SetAllocated(client_country, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.client_country_.IsDefault()) {
+    _impl_.client_country_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.client_country)
+}
+
+// optional bool did_proceed = 8;
+inline bool ClientSafeBrowsingReportRequest::_internal_has_did_proceed() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest::has_did_proceed() const {
+  return _internal_has_did_proceed();
+}
+inline void ClientSafeBrowsingReportRequest::clear_did_proceed() {
+  _impl_.did_proceed_ = false;
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline bool ClientSafeBrowsingReportRequest::_internal_did_proceed() const {
+  return _impl_.did_proceed_;
+}
+inline bool ClientSafeBrowsingReportRequest::did_proceed() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.did_proceed)
+  return _internal_did_proceed();
+}
+inline void ClientSafeBrowsingReportRequest::_internal_set_did_proceed(bool value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.did_proceed_ = value;
+}
+inline void ClientSafeBrowsingReportRequest::set_did_proceed(bool value) {
+  _internal_set_did_proceed(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.did_proceed)
+}
+
+// optional bool repeat_visit = 9;
+inline bool ClientSafeBrowsingReportRequest::_internal_has_repeat_visit() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest::has_repeat_visit() const {
+  return _internal_has_repeat_visit();
+}
+inline void ClientSafeBrowsingReportRequest::clear_repeat_visit() {
+  _impl_.repeat_visit_ = false;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline bool ClientSafeBrowsingReportRequest::_internal_repeat_visit() const {
+  return _impl_.repeat_visit_;
+}
+inline bool ClientSafeBrowsingReportRequest::repeat_visit() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.repeat_visit)
+  return _internal_repeat_visit();
+}
+inline void ClientSafeBrowsingReportRequest::_internal_set_repeat_visit(bool value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.repeat_visit_ = value;
+}
+inline void ClientSafeBrowsingReportRequest::set_repeat_visit(bool value) {
+  _internal_set_repeat_visit(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.repeat_visit)
+}
+
+// optional bytes token = 15;
+inline bool ClientSafeBrowsingReportRequest::_internal_has_token() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest::has_token() const {
+  return _internal_has_token();
+}
+inline void ClientSafeBrowsingReportRequest::clear_token() {
+  _impl_.token_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& ClientSafeBrowsingReportRequest::token() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.token)
+  return _internal_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientSafeBrowsingReportRequest::set_token(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.token_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.token)
+}
+inline std::string* ClientSafeBrowsingReportRequest::mutable_token() {
+  std::string* _s = _internal_mutable_token();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.token)
+  return _s;
+}
+inline const std::string& ClientSafeBrowsingReportRequest::_internal_token() const {
+  return _impl_.token_.Get();
+}
+inline void ClientSafeBrowsingReportRequest::_internal_set_token(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.token_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest::_internal_mutable_token() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.token_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ClientSafeBrowsingReportRequest::release_token() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.token)
+  if (!_internal_has_token()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.token_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.token_.IsDefault()) {
+    _impl_.token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ClientSafeBrowsingReportRequest::set_allocated_token(std::string* token) {
+  if (token != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.token_.SetAllocated(token, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.token_.IsDefault()) {
+    _impl_.token_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.token)
+}
+
+// optional .safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties client_properties = 17;
+inline bool ClientSafeBrowsingReportRequest::_internal_has_client_properties() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.client_properties_ != nullptr);
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest::has_client_properties() const {
+  return _internal_has_client_properties();
+}
+inline void ClientSafeBrowsingReportRequest::clear_client_properties() {
+  if (_impl_.client_properties_ != nullptr) _impl_.client_properties_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& ClientSafeBrowsingReportRequest::_internal_client_properties() const {
+  const ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* p = _impl_.client_properties_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties&>(
+      ::safe_browsing::_ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_default_instance_);
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& ClientSafeBrowsingReportRequest::client_properties() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.client_properties)
+  return _internal_client_properties();
+}
+inline void ClientSafeBrowsingReportRequest::unsafe_arena_set_allocated_client_properties(
+    ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* client_properties) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_properties_);
+  }
+  _impl_.client_properties_ = client_properties;
+  if (client_properties) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.client_properties)
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* ClientSafeBrowsingReportRequest::release_client_properties() {
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* temp = _impl_.client_properties_;
+  _impl_.client_properties_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* ClientSafeBrowsingReportRequest::unsafe_arena_release_client_properties() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.client_properties)
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* temp = _impl_.client_properties_;
+  _impl_.client_properties_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* ClientSafeBrowsingReportRequest::_internal_mutable_client_properties() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.client_properties_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties>(GetArenaForAllocation());
+    _impl_.client_properties_ = p;
+  }
+  return _impl_.client_properties_;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* ClientSafeBrowsingReportRequest::mutable_client_properties() {
+  ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* _msg = _internal_mutable_client_properties();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.client_properties)
+  return _msg;
+}
+inline void ClientSafeBrowsingReportRequest::set_allocated_client_properties(::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* client_properties) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.client_properties_;
+  }
+  if (client_properties) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(client_properties);
+    if (message_arena != submessage_arena) {
+      client_properties = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, client_properties, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.client_properties_ = client_properties;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.client_properties)
+}
+
+// optional bool show_download_in_folder = 18;
+inline bool ClientSafeBrowsingReportRequest::_internal_has_show_download_in_folder() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool ClientSafeBrowsingReportRequest::has_show_download_in_folder() const {
+  return _internal_has_show_download_in_folder();
+}
+inline void ClientSafeBrowsingReportRequest::clear_show_download_in_folder() {
+  _impl_.show_download_in_folder_ = false;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline bool ClientSafeBrowsingReportRequest::_internal_show_download_in_folder() const {
+  return _impl_.show_download_in_folder_;
+}
+inline bool ClientSafeBrowsingReportRequest::show_download_in_folder() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.show_download_in_folder)
+  return _internal_show_download_in_folder();
+}
+inline void ClientSafeBrowsingReportRequest::_internal_set_show_download_in_folder(bool value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.show_download_in_folder_ = value;
+}
+inline void ClientSafeBrowsingReportRequest::set_show_download_in_folder(bool value) {
+  _internal_set_show_download_in_folder(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.show_download_in_folder)
+}
+
+// -------------------------------------------------------------------
+
+// HTMLElement_Attribute
+
+// optional string name = 1;
+inline bool HTMLElement_Attribute::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool HTMLElement_Attribute::has_name() const {
+  return _internal_has_name();
+}
+inline void HTMLElement_Attribute::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& HTMLElement_Attribute::name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.HTMLElement.Attribute.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HTMLElement_Attribute::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.HTMLElement.Attribute.name)
+}
+inline std::string* HTMLElement_Attribute::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.HTMLElement.Attribute.name)
+  return _s;
+}
+inline const std::string& HTMLElement_Attribute::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void HTMLElement_Attribute::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HTMLElement_Attribute::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HTMLElement_Attribute::release_name() {
+  // @@protoc_insertion_point(field_release:safe_browsing.HTMLElement.Attribute.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HTMLElement_Attribute::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.HTMLElement.Attribute.name)
+}
+
+// optional string value = 2;
+inline bool HTMLElement_Attribute::_internal_has_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool HTMLElement_Attribute::has_value() const {
+  return _internal_has_value();
+}
+inline void HTMLElement_Attribute::clear_value() {
+  _impl_.value_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& HTMLElement_Attribute::value() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.HTMLElement.Attribute.value)
+  return _internal_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HTMLElement_Attribute::set_value(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.HTMLElement.Attribute.value)
+}
+inline std::string* HTMLElement_Attribute::mutable_value() {
+  std::string* _s = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.HTMLElement.Attribute.value)
+  return _s;
+}
+inline const std::string& HTMLElement_Attribute::_internal_value() const {
+  return _impl_.value_.Get();
+}
+inline void HTMLElement_Attribute::_internal_set_value(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HTMLElement_Attribute::_internal_mutable_value() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HTMLElement_Attribute::release_value() {
+  // @@protoc_insertion_point(field_release:safe_browsing.HTMLElement.Attribute.value)
+  if (!_internal_has_value()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.value_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.value_.IsDefault()) {
+    _impl_.value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HTMLElement_Attribute::set_allocated_value(std::string* value) {
+  if (value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.value_.IsDefault()) {
+    _impl_.value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.HTMLElement.Attribute.value)
+}
+
+// -------------------------------------------------------------------
+
+// HTMLElement
+
+// optional int32 id = 1;
+inline bool HTMLElement::_internal_has_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool HTMLElement::has_id() const {
+  return _internal_has_id();
+}
+inline void HTMLElement::clear_id() {
+  _impl_.id_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t HTMLElement::_internal_id() const {
+  return _impl_.id_;
+}
+inline int32_t HTMLElement::id() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.HTMLElement.id)
+  return _internal_id();
+}
+inline void HTMLElement::_internal_set_id(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.id_ = value;
+}
+inline void HTMLElement::set_id(int32_t value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.HTMLElement.id)
+}
+
+// optional string tag = 2;
+inline bool HTMLElement::_internal_has_tag() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool HTMLElement::has_tag() const {
+  return _internal_has_tag();
+}
+inline void HTMLElement::clear_tag() {
+  _impl_.tag_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& HTMLElement::tag() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.HTMLElement.tag)
+  return _internal_tag();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void HTMLElement::set_tag(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.tag_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.HTMLElement.tag)
+}
+inline std::string* HTMLElement::mutable_tag() {
+  std::string* _s = _internal_mutable_tag();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.HTMLElement.tag)
+  return _s;
+}
+inline const std::string& HTMLElement::_internal_tag() const {
+  return _impl_.tag_.Get();
+}
+inline void HTMLElement::_internal_set_tag(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.tag_.Set(value, GetArenaForAllocation());
+}
+inline std::string* HTMLElement::_internal_mutable_tag() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.tag_.Mutable(GetArenaForAllocation());
+}
+inline std::string* HTMLElement::release_tag() {
+  // @@protoc_insertion_point(field_release:safe_browsing.HTMLElement.tag)
+  if (!_internal_has_tag()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.tag_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.tag_.IsDefault()) {
+    _impl_.tag_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void HTMLElement::set_allocated_tag(std::string* tag) {
+  if (tag != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.tag_.SetAllocated(tag, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.tag_.IsDefault()) {
+    _impl_.tag_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.HTMLElement.tag)
+}
+
+// repeated int32 child_ids = 3;
+inline int HTMLElement::_internal_child_ids_size() const {
+  return _impl_.child_ids_.size();
+}
+inline int HTMLElement::child_ids_size() const {
+  return _internal_child_ids_size();
+}
+inline void HTMLElement::clear_child_ids() {
+  _impl_.child_ids_.Clear();
+}
+inline int32_t HTMLElement::_internal_child_ids(int index) const {
+  return _impl_.child_ids_.Get(index);
+}
+inline int32_t HTMLElement::child_ids(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.HTMLElement.child_ids)
+  return _internal_child_ids(index);
+}
+inline void HTMLElement::set_child_ids(int index, int32_t value) {
+  _impl_.child_ids_.Set(index, value);
+  // @@protoc_insertion_point(field_set:safe_browsing.HTMLElement.child_ids)
+}
+inline void HTMLElement::_internal_add_child_ids(int32_t value) {
+  _impl_.child_ids_.Add(value);
+}
+inline void HTMLElement::add_child_ids(int32_t value) {
+  _internal_add_child_ids(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.HTMLElement.child_ids)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+HTMLElement::_internal_child_ids() const {
+  return _impl_.child_ids_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+HTMLElement::child_ids() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.HTMLElement.child_ids)
+  return _internal_child_ids();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+HTMLElement::_internal_mutable_child_ids() {
+  return &_impl_.child_ids_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+HTMLElement::mutable_child_ids() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.HTMLElement.child_ids)
+  return _internal_mutable_child_ids();
+}
+
+// optional int32 resource_id = 5;
+inline bool HTMLElement::_internal_has_resource_id() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool HTMLElement::has_resource_id() const {
+  return _internal_has_resource_id();
+}
+inline void HTMLElement::clear_resource_id() {
+  _impl_.resource_id_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t HTMLElement::_internal_resource_id() const {
+  return _impl_.resource_id_;
+}
+inline int32_t HTMLElement::resource_id() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.HTMLElement.resource_id)
+  return _internal_resource_id();
+}
+inline void HTMLElement::_internal_set_resource_id(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.resource_id_ = value;
+}
+inline void HTMLElement::set_resource_id(int32_t value) {
+  _internal_set_resource_id(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.HTMLElement.resource_id)
+}
+
+// repeated .safe_browsing.HTMLElement.Attribute attribute = 6;
+inline int HTMLElement::_internal_attribute_size() const {
+  return _impl_.attribute_.size();
+}
+inline int HTMLElement::attribute_size() const {
+  return _internal_attribute_size();
+}
+inline void HTMLElement::clear_attribute() {
+  _impl_.attribute_.Clear();
+}
+inline ::safe_browsing::HTMLElement_Attribute* HTMLElement::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.HTMLElement.attribute)
+  return _impl_.attribute_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::HTMLElement_Attribute >*
+HTMLElement::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.HTMLElement.attribute)
+  return &_impl_.attribute_;
+}
+inline const ::safe_browsing::HTMLElement_Attribute& HTMLElement::_internal_attribute(int index) const {
+  return _impl_.attribute_.Get(index);
+}
+inline const ::safe_browsing::HTMLElement_Attribute& HTMLElement::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.HTMLElement.attribute)
+  return _internal_attribute(index);
+}
+inline ::safe_browsing::HTMLElement_Attribute* HTMLElement::_internal_add_attribute() {
+  return _impl_.attribute_.Add();
+}
+inline ::safe_browsing::HTMLElement_Attribute* HTMLElement::add_attribute() {
+  ::safe_browsing::HTMLElement_Attribute* _add = _internal_add_attribute();
+  // @@protoc_insertion_point(field_add:safe_browsing.HTMLElement.attribute)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::HTMLElement_Attribute >&
+HTMLElement::attribute() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.HTMLElement.attribute)
+  return _impl_.attribute_;
+}
+
+// -------------------------------------------------------------------
+
+// ImageData_Dimensions
+
+// optional int32 width = 1;
+inline bool ImageData_Dimensions::_internal_has_width() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ImageData_Dimensions::has_width() const {
+  return _internal_has_width();
+}
+inline void ImageData_Dimensions::clear_width() {
+  _impl_.width_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int32_t ImageData_Dimensions::_internal_width() const {
+  return _impl_.width_;
+}
+inline int32_t ImageData_Dimensions::width() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ImageData.Dimensions.width)
+  return _internal_width();
+}
+inline void ImageData_Dimensions::_internal_set_width(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.width_ = value;
+}
+inline void ImageData_Dimensions::set_width(int32_t value) {
+  _internal_set_width(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ImageData.Dimensions.width)
+}
+
+// optional int32 height = 2;
+inline bool ImageData_Dimensions::_internal_has_height() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ImageData_Dimensions::has_height() const {
+  return _internal_has_height();
+}
+inline void ImageData_Dimensions::clear_height() {
+  _impl_.height_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t ImageData_Dimensions::_internal_height() const {
+  return _impl_.height_;
+}
+inline int32_t ImageData_Dimensions::height() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ImageData.Dimensions.height)
+  return _internal_height();
+}
+inline void ImageData_Dimensions::_internal_set_height(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.height_ = value;
+}
+inline void ImageData_Dimensions::set_height(int32_t value) {
+  _internal_set_height(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ImageData.Dimensions.height)
+}
+
+// -------------------------------------------------------------------
+
+// ImageData
+
+// optional bytes data = 1;
+inline bool ImageData::_internal_has_data() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ImageData::has_data() const {
+  return _internal_has_data();
+}
+inline void ImageData::clear_data() {
+  _impl_.data_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ImageData::data() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ImageData.data)
+  return _internal_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ImageData::set_data(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ImageData.data)
+}
+inline std::string* ImageData::mutable_data() {
+  std::string* _s = _internal_mutable_data();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ImageData.data)
+  return _s;
+}
+inline const std::string& ImageData::_internal_data() const {
+  return _impl_.data_.Get();
+}
+inline void ImageData::_internal_set_data(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.data_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ImageData::_internal_mutable_data() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.data_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ImageData::release_data() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ImageData.data)
+  if (!_internal_has_data()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.data_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.data_.IsDefault()) {
+    _impl_.data_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ImageData::set_allocated_data(std::string* data) {
+  if (data != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.data_.IsDefault()) {
+    _impl_.data_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ImageData.data)
+}
+
+// optional string mime_type = 2;
+inline bool ImageData::_internal_has_mime_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ImageData::has_mime_type() const {
+  return _internal_has_mime_type();
+}
+inline void ImageData::clear_mime_type() {
+  _impl_.mime_type_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ImageData::mime_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ImageData.mime_type)
+  return _internal_mime_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ImageData::set_mime_type(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.mime_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.ImageData.mime_type)
+}
+inline std::string* ImageData::mutable_mime_type() {
+  std::string* _s = _internal_mutable_mime_type();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ImageData.mime_type)
+  return _s;
+}
+inline const std::string& ImageData::_internal_mime_type() const {
+  return _impl_.mime_type_.Get();
+}
+inline void ImageData::_internal_set_mime_type(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.mime_type_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ImageData::_internal_mutable_mime_type() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.mime_type_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ImageData::release_mime_type() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ImageData.mime_type)
+  if (!_internal_has_mime_type()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.mime_type_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mime_type_.IsDefault()) {
+    _impl_.mime_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ImageData::set_allocated_mime_type(std::string* mime_type) {
+  if (mime_type != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.mime_type_.SetAllocated(mime_type, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.mime_type_.IsDefault()) {
+    _impl_.mime_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ImageData.mime_type)
+}
+
+// optional .safe_browsing.ImageData.Dimensions dimensions = 3;
+inline bool ImageData::_internal_has_dimensions() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.dimensions_ != nullptr);
+  return value;
+}
+inline bool ImageData::has_dimensions() const {
+  return _internal_has_dimensions();
+}
+inline void ImageData::clear_dimensions() {
+  if (_impl_.dimensions_ != nullptr) _impl_.dimensions_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const ::safe_browsing::ImageData_Dimensions& ImageData::_internal_dimensions() const {
+  const ::safe_browsing::ImageData_Dimensions* p = _impl_.dimensions_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ImageData_Dimensions&>(
+      ::safe_browsing::_ImageData_Dimensions_default_instance_);
+}
+inline const ::safe_browsing::ImageData_Dimensions& ImageData::dimensions() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ImageData.dimensions)
+  return _internal_dimensions();
+}
+inline void ImageData::unsafe_arena_set_allocated_dimensions(
+    ::safe_browsing::ImageData_Dimensions* dimensions) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dimensions_);
+  }
+  _impl_.dimensions_ = dimensions;
+  if (dimensions) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ImageData.dimensions)
+}
+inline ::safe_browsing::ImageData_Dimensions* ImageData::release_dimensions() {
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ImageData_Dimensions* temp = _impl_.dimensions_;
+  _impl_.dimensions_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ImageData_Dimensions* ImageData::unsafe_arena_release_dimensions() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ImageData.dimensions)
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  ::safe_browsing::ImageData_Dimensions* temp = _impl_.dimensions_;
+  _impl_.dimensions_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ImageData_Dimensions* ImageData::_internal_mutable_dimensions() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  if (_impl_.dimensions_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ImageData_Dimensions>(GetArenaForAllocation());
+    _impl_.dimensions_ = p;
+  }
+  return _impl_.dimensions_;
+}
+inline ::safe_browsing::ImageData_Dimensions* ImageData::mutable_dimensions() {
+  ::safe_browsing::ImageData_Dimensions* _msg = _internal_mutable_dimensions();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ImageData.dimensions)
+  return _msg;
+}
+inline void ImageData::set_allocated_dimensions(::safe_browsing::ImageData_Dimensions* dimensions) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.dimensions_;
+  }
+  if (dimensions) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dimensions);
+    if (message_arena != submessage_arena) {
+      dimensions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, dimensions, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.dimensions_ = dimensions;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ImageData.dimensions)
+}
+
+// optional .safe_browsing.ImageData.Dimensions original_dimensions = 4;
+inline bool ImageData::_internal_has_original_dimensions() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.original_dimensions_ != nullptr);
+  return value;
+}
+inline bool ImageData::has_original_dimensions() const {
+  return _internal_has_original_dimensions();
+}
+inline void ImageData::clear_original_dimensions() {
+  if (_impl_.original_dimensions_ != nullptr) _impl_.original_dimensions_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::safe_browsing::ImageData_Dimensions& ImageData::_internal_original_dimensions() const {
+  const ::safe_browsing::ImageData_Dimensions* p = _impl_.original_dimensions_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ImageData_Dimensions&>(
+      ::safe_browsing::_ImageData_Dimensions_default_instance_);
+}
+inline const ::safe_browsing::ImageData_Dimensions& ImageData::original_dimensions() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ImageData.original_dimensions)
+  return _internal_original_dimensions();
+}
+inline void ImageData::unsafe_arena_set_allocated_original_dimensions(
+    ::safe_browsing::ImageData_Dimensions* original_dimensions) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.original_dimensions_);
+  }
+  _impl_.original_dimensions_ = original_dimensions;
+  if (original_dimensions) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.ImageData.original_dimensions)
+}
+inline ::safe_browsing::ImageData_Dimensions* ImageData::release_original_dimensions() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::safe_browsing::ImageData_Dimensions* temp = _impl_.original_dimensions_;
+  _impl_.original_dimensions_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ImageData_Dimensions* ImageData::unsafe_arena_release_original_dimensions() {
+  // @@protoc_insertion_point(field_release:safe_browsing.ImageData.original_dimensions)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::safe_browsing::ImageData_Dimensions* temp = _impl_.original_dimensions_;
+  _impl_.original_dimensions_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ImageData_Dimensions* ImageData::_internal_mutable_original_dimensions() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.original_dimensions_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ImageData_Dimensions>(GetArenaForAllocation());
+    _impl_.original_dimensions_ = p;
+  }
+  return _impl_.original_dimensions_;
+}
+inline ::safe_browsing::ImageData_Dimensions* ImageData::mutable_original_dimensions() {
+  ::safe_browsing::ImageData_Dimensions* _msg = _internal_mutable_original_dimensions();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ImageData.original_dimensions)
+  return _msg;
+}
+inline void ImageData::set_allocated_original_dimensions(::safe_browsing::ImageData_Dimensions* original_dimensions) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.original_dimensions_;
+  }
+  if (original_dimensions) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(original_dimensions);
+    if (message_arena != submessage_arena) {
+      original_dimensions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, original_dimensions, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.original_dimensions_ = original_dimensions;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ImageData.original_dimensions)
+}
+
+// -------------------------------------------------------------------
+
+// NotificationImageReportRequest
+
+// optional string notification_origin = 1;
+inline bool NotificationImageReportRequest::_internal_has_notification_origin() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool NotificationImageReportRequest::has_notification_origin() const {
+  return _internal_has_notification_origin();
+}
+inline void NotificationImageReportRequest::clear_notification_origin() {
+  _impl_.notification_origin_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& NotificationImageReportRequest::notification_origin() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.NotificationImageReportRequest.notification_origin)
+  return _internal_notification_origin();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void NotificationImageReportRequest::set_notification_origin(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.notification_origin_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:safe_browsing.NotificationImageReportRequest.notification_origin)
+}
+inline std::string* NotificationImageReportRequest::mutable_notification_origin() {
+  std::string* _s = _internal_mutable_notification_origin();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.NotificationImageReportRequest.notification_origin)
+  return _s;
+}
+inline const std::string& NotificationImageReportRequest::_internal_notification_origin() const {
+  return _impl_.notification_origin_.Get();
+}
+inline void NotificationImageReportRequest::_internal_set_notification_origin(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.notification_origin_.Set(value, GetArenaForAllocation());
+}
+inline std::string* NotificationImageReportRequest::_internal_mutable_notification_origin() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.notification_origin_.Mutable(GetArenaForAllocation());
+}
+inline std::string* NotificationImageReportRequest::release_notification_origin() {
+  // @@protoc_insertion_point(field_release:safe_browsing.NotificationImageReportRequest.notification_origin)
+  if (!_internal_has_notification_origin()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.notification_origin_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.notification_origin_.IsDefault()) {
+    _impl_.notification_origin_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void NotificationImageReportRequest::set_allocated_notification_origin(std::string* notification_origin) {
+  if (notification_origin != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.notification_origin_.SetAllocated(notification_origin, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.notification_origin_.IsDefault()) {
+    _impl_.notification_origin_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.NotificationImageReportRequest.notification_origin)
+}
+
+// optional .safe_browsing.ImageData image = 2;
+inline bool NotificationImageReportRequest::_internal_has_image() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.image_ != nullptr);
+  return value;
+}
+inline bool NotificationImageReportRequest::has_image() const {
+  return _internal_has_image();
+}
+inline void NotificationImageReportRequest::clear_image() {
+  if (_impl_.image_ != nullptr) _impl_.image_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::safe_browsing::ImageData& NotificationImageReportRequest::_internal_image() const {
+  const ::safe_browsing::ImageData* p = _impl_.image_;
+  return p != nullptr ? *p : reinterpret_cast<const ::safe_browsing::ImageData&>(
+      ::safe_browsing::_ImageData_default_instance_);
+}
+inline const ::safe_browsing::ImageData& NotificationImageReportRequest::image() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.NotificationImageReportRequest.image)
+  return _internal_image();
+}
+inline void NotificationImageReportRequest::unsafe_arena_set_allocated_image(
+    ::safe_browsing::ImageData* image) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.image_);
+  }
+  _impl_.image_ = image;
+  if (image) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:safe_browsing.NotificationImageReportRequest.image)
+}
+inline ::safe_browsing::ImageData* NotificationImageReportRequest::release_image() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ImageData* temp = _impl_.image_;
+  _impl_.image_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::safe_browsing::ImageData* NotificationImageReportRequest::unsafe_arena_release_image() {
+  // @@protoc_insertion_point(field_release:safe_browsing.NotificationImageReportRequest.image)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::safe_browsing::ImageData* temp = _impl_.image_;
+  _impl_.image_ = nullptr;
+  return temp;
+}
+inline ::safe_browsing::ImageData* NotificationImageReportRequest::_internal_mutable_image() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.image_ == nullptr) {
+    auto* p = CreateMaybeMessage<::safe_browsing::ImageData>(GetArenaForAllocation());
+    _impl_.image_ = p;
+  }
+  return _impl_.image_;
+}
+inline ::safe_browsing::ImageData* NotificationImageReportRequest::mutable_image() {
+  ::safe_browsing::ImageData* _msg = _internal_mutable_image();
+  // @@protoc_insertion_point(field_mutable:safe_browsing.NotificationImageReportRequest.image)
+  return _msg;
+}
+inline void NotificationImageReportRequest::set_allocated_image(::safe_browsing::ImageData* image) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.image_;
+  }
+  if (image) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(image);
+    if (message_arena != submessage_arena) {
+      image = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, image, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.image_ = image;
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.NotificationImageReportRequest.image)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace safe_browsing
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::safe_browsing::ChromeUserPopulation_UserPopulation> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent_SyncAccountType> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::LoginReputationClientRequest_TriggerType> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::LoginReputationClientResponse_VerdictType> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ClientDownloadRequest_ResourceType> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ClientDownloadRequest_DownloadType> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ReferrerChainEntry_URLType> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ClientDownloadResponse_Verdict> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ClientDownloadReport_Reason> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ClientUploadResponse_UploadStatus> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ClientSafeBrowsingReportRequest_ReportType> : ::std::true_type {};
+template <> struct is_proto_enum< ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType> : ::std::true_type {};
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_csd_2eproto
diff --git a/toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.proto b/toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.proto
new file mode 100644
index 0000000000..4a5282bf2f
--- /dev/null
+++ b/toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.proto
@@ -0,0 +1,1092 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// This proto file includes:
+// (1) Client side phishing and malware detection request and response
+//   protocol buffers.  Those protocol messages should be kept in sync
+//   with the server implementation.
+//
+// (2) Safe Browsing reporting protocol buffers.
+//   A ClientSafeBrowsingReportRequest is sent when a user opts-in to
+//   sending detailed threat reports from the safe browsing interstitial page.
+//   It is a list of Resource messages, which may contain the url of a
+//   resource such as the page in the address bar or any other resource
+//   that was loaded for this page.
+//   In addition to the url, a resource can contain HTTP request and response
+//   headers and bodies.
+//
+// If you want to change this protocol definition or you have questions
+// regarding its format please contact chrome-anti-phishing@googlegroups.com.
+
+syntax = "proto2";
+
+option optimize_for = LITE_RUNTIME;
+
+package safe_browsing;
+
+// Protocol buffer describing the Chrome user population of the user reporting
+// data.
+message ChromeUserPopulation {
+  enum UserPopulation {
+    UNKNOWN_USER_POPULATION = 0;
+    SAFE_BROWSING = 1;
+    EXTENDED_REPORTING = 2;
+  }
+  optional UserPopulation user_population = 1;
+
+  // If user enabled history sync.
+  optional bool is_history_sync_enabled = 2;
+
+  // The finch active groups this user belongs to (if any). Active group is
+  // defined by finch trial name and group name. Trial name and group name are
+  // concatenated with separator "|", e.g. "PingOnlyTrial|DefaultGroup".
+  repeated string finch_active_groups = 4;
+}
+
+message ClientPhishingRequest {
+  // URL that the client visited.  The CGI parameters are stripped by the
+  // client.
+  optional string url = 1;
+
+  // A 5-byte SHA-256 hash prefix of the URL.  Before hashing the URL is
+  // canonicalized, converted to a suffix-prefix expression and broadened
+  // (www prefix is removed and everything past the last '/' is stripped).
+  //
+  // Marked OBSOLETE because the URL is sent for all users, making the hash
+  // prefix unnecessary.
+  optional bytes OBSOLETE_hash_prefix = 10;
+
+  // Score that was computed on the client.  Value is between 0.0 and 1.0.
+  // The larger the value the more likely the url is phishing.
+  required float client_score = 2;
+
+  // Note: we're skipping tag 3 because it was previously used.
+
+  // Is true if the features for this URL were classified as phishing.
+  // Currently, this will always be true for all client-phishing requests
+  // that are sent to the server.
+  optional bool is_phishing = 4;
+
+  message Feature {
+    // Feature name.  E.g., 'PageHasForms'.
+    required string name = 1;
+
+    // Feature value is always in the range [0.0, 1.0].  Boolean features
+    // have value 1.0.
+    required double value = 2;
+  }
+
+  // List of features that were extracted.  Those are the features that were
+  // sent to the scorer and which resulted in client_score being computed.
+  repeated Feature feature_map = 5;
+
+  // The version number of the model that was used to compute the client-score.
+  // Copied from ClientSideModel.version().
+  optional int32 model_version = 6;
+
+  // Field 7 is only used on the server.
+
+  // List of features that are extracted in the client but are not used in the
+  // machine learning model.
+  repeated Feature non_model_feature_map = 8;
+
+  // The referrer URL.  This field might not be set, for example, in the case
+  // where the referrer uses HTTPs.
+  // OBSOLETE: Use feature 'Referrer=<referrer>' instead.
+  optional string OBSOLETE_referrer_url = 9;
+
+  // Field 11 is only used on the server.
+
+  // List of shingle hashes we extracted.
+  repeated uint32 shingle_hashes = 12 [packed = true];
+
+  // The model filename (basename) that was used by the client.
+  optional string model_filename = 13;
+
+  // Population that the reporting user is part of.
+  optional ChromeUserPopulation population = 14;
+}
+
+message ClientPhishingResponse {
+  required bool phishy = 1;
+
+  // A list of SafeBrowsing host-suffix / path-prefix expressions that
+  // are whitelisted.  The client must match the current top-level URL
+  // against these whitelisted expressions and only apply a positive
+  // phishing verdict above if the URL does not match any expression
+  // on this whitelist.  The client must not cache these whitelisted
+  // expressions.  This whitelist will be empty for the vast majority
+  // of the responses but might contain up to 100 entries in emergency
+  // situations.
+  //
+  // Marked OBSOLETE because the URL is sent for all users, so the server
+  // can do whitelist matching.
+  repeated string OBSOLETE_whitelist_expression = 2;
+}
+
+message ClientMalwareRequest {
+  // URL that the client visited.  The CGI parameters are stripped by the
+  // client.
+  required string url = 1;
+
+  // Field 2 is deleted and no longer in use.
+
+  // Field 3 is only used on the server.
+
+  // The referrer URL.  This field might not be set, for example, in the case
+  // where the referrer uses HTTPS.
+  optional string referrer_url = 4;
+
+  // Field 5 and 6 are only used on the server.
+
+  message UrlInfo {
+    required string ip = 1;
+    required string url = 2;
+    optional string method = 3;
+    optional string referrer = 4;
+    // Resource type, the int value is a direct cast from the Type enum
+    // of ResourceType class defined in //src/webkit/commom/resource_type.h
+    optional int32 resource_type = 5;
+  }
+
+  // List of resource urls that match the malware IP list.
+  repeated UrlInfo bad_ip_url_info = 7;
+
+  // Population that the reporting user is part of.
+  optional ChromeUserPopulation population = 9;
+}
+
+// The message is used for client request to determine whether the provided URL
+// is safe for the purposes of entering user credentials for logging in.
+message LoginReputationClientRequest {
+  // The top level frame URL of the webpage that hosts the login form.
+  optional string page_url = 1;
+
+  // Type for the request.
+  // It could be low reputation request or password reuse request.
+  enum TriggerType {
+    TRIGGER_TYPE_UNSPECIFIED = 0;
+    UNFAMILIAR_LOGIN_PAGE = 1;
+    PASSWORD_REUSE_EVENT = 2;
+  }
+  optional TriggerType trigger_type = 2;
+
+  // The message contains features which can describe a frame. A frame can be
+  // a top level web page or an iframe.
+  message Frame {
+    // Id of a frame. The frame whose index = 0 is the top level web page.
+    optional int32 frame_index = 1;
+
+    // Id of the parent frame.
+    optional int32 parent_frame_index = 2;
+
+    // Url of the frame. If could be top level url (from web page) or url of
+    // the iframe.
+    optional string url = 3;
+
+    // Whether the frame contains password field.
+    optional bool has_password_field = 4;
+
+    // URLs transitions in reverse chronological order, i.e. the top level url
+    // or the url of the iframe comes first in the list.
+    repeated ReferrerChainEntry referrer_chain = 5;
+
+    // The message contains features of a form.
+    message Form {
+      // Action url of the form.
+      optional string action_url = 1;
+
+      // Whether the form contains password field.
+      optional bool has_password_field = 2;
+    }
+
+    repeated Form forms = 6;
+  }
+
+  repeated Frame frames = 3;
+
+  // The message contains fields needed for a password reuse event.
+  // Next tag: 4
+  message PasswordReuseEvent {
+    // Domains from the Chrome password manager DB that are associated with
+    // the same password as the one triggering this event. The field is filled
+    // in only when TriggerType is PASSWORD_REUSE_EVENT, and only for users
+    // opted in to extended reporting.
+    repeated string domains_matching_password = 1;
+
+    // The frame that the password reuse is detected.
+    optional int32 frame_id = 2;
+
+    // Whether the reused password is used for Chrome signin.
+    optional bool is_chrome_signin_password = 3;
+
+    // Sync account type. Only set if |is_chrome_signin_password| is true.
+    enum SyncAccountType {
+      // Not a sign-in user.
+      NOT_SIGNED_IN = 0;
+
+      // User signed in with @gmail.com, or @googlemail.com account.
+      GMAIL = 1;
+
+      // User signed in with a G Suite account.
+      GSUITE = 2;
+    }
+    optional SyncAccountType sync_account_type = 4;
+  }
+
+  optional PasswordReuseEvent password_reuse_event = 4;
+
+  // The number of verdicts stored on the client.
+  optional int32 stored_verdict_cnt = 5;
+
+  // Chrome user population.
+  optional ChromeUserPopulation population = 6;
+
+  // If user clicked through safe browsing interstitial on this page.
+  optional bool clicked_through_interstitial = 7;
+}
+
+// The message is used for client response for login reputation requests.
+message LoginReputationClientResponse {
+  // Type of verdicts issued by the server.
+  enum VerdictType {
+    VERDICT_TYPE_UNSPECIFIED = 0;
+    // No warning will be displayed.
+    SAFE = 1;
+    // The site has low reputation or low popularity.
+    LOW_REPUTATION = 2;
+    // The url matches with blacklist entries.
+    PHISHING = 3;
+  }
+  optional VerdictType verdict_type = 1;
+
+  // TTL of the verdict in seconds.
+  optional int64 cache_duration_sec = 2;
+
+  // A host-suffix/path-prefix expression which defines a collections of pages
+  // with common ownership from the same domain.
+  // Generally, the pattern is defined on the granularity of domains.
+  // For domains managed by multiple parties, especially in the case of large
+  // hosting sites (e.g., geocities.com), we further divide the domains.
+  //
+  // Examples:
+  //    www.google.com/foo/bar?param=val -> google.com
+  //    www.geocities.com/foo/bar.html -> geocities.com/foo
+  //    adwords.blogspot.com/index.html -> adwords.blogspot.com
+  //
+  // The pattern will always match the page_url of the request, and will be
+  // a substring of page_url.
+  optional string cache_expression = 3;
+
+  // Deprecated.
+  optional bool DEPRECATED_cache_expression_exact_match = 4 [deprecated = true];
+
+  // A token unique to each request which correlates response and post-warning
+  // actions.
+  optional bytes verdict_token = 5;
+}
+
+message ClientMalwareResponse {
+  required bool blacklist = 1;
+  // The confirmed blacklisted bad IP and its url, which will be shown in
+  // malware warning, if the blacklist verdict is true.
+  // This IP string could be either in IPv4 or IPv6 format, which is the same
+  // as the ones client sent to server.
+  optional string bad_ip = 2;
+  optional string bad_url = 3;
+}
+
+message ClientDownloadRequest {
+  // The final URL of the download (after all redirects).
+  required string url = 1;
+
+  // This message contains various binary digests of the download payload.
+  message Digests {
+    optional bytes sha256 = 1;
+    optional bytes sha1 = 2;
+    optional bytes md5 = 3;
+  }
+  required Digests digests = 2;
+
+  // This is the length in bytes of the download payload.
+  required int64 length = 3;
+
+  // Type of the resources stored below.
+  enum ResourceType {
+    // The final URL of the download payload.  The resource URL should
+    // correspond to the URL field above.
+    DOWNLOAD_URL = 0;
+    // A redirect URL that was fetched before hitting the final DOWNLOAD_URL.
+    DOWNLOAD_REDIRECT = 1;
+    // The final top-level URL of the tab that triggered the download.
+    TAB_URL = 2;
+    // A redirect URL thas was fetched before hitting the final TAB_URL.
+    TAB_REDIRECT = 3;
+    // The document URL for a PPAPI plugin instance that initiated the download.
+    // This is the document.url for the container element for the plugin
+    // instance.
+    PPAPI_DOCUMENT = 4;
+    // The plugin URL for a PPAPI plugin instance that initiated the download.
+    PPAPI_PLUGIN = 5;
+  }
+
+  message Resource {
+    required string url = 1;
+    required ResourceType type = 2;
+    optional bytes remote_ip = 3;
+    // This will only be set if the referrer is available and if the
+    // resource type is either TAB_URL or DOWNLOAD_URL.
+    optional string referrer = 4;
+
+    // TODO(noelutz): add the transition type?
+  }
+
+  // This repeated field will store all the redirects as well as the
+  // final URLs for the top-level tab URL (i.e., the URL that
+  // triggered the download) as well as for the download URL itself.
+  repeated Resource resources = 4;
+
+  // A trust chain of certificates.  Each chain begins with the signing
+  // certificate of the binary, and ends with a self-signed certificate,
+  // typically from a trusted root CA.  This structure is analogous to
+  // CERT_CHAIN_CONTEXT on Windows.
+  message CertificateChain {
+    // A single link in the chain.
+    message Element {
+      // DER-encoded X.509 representation of the certificate.
+      optional bytes certificate = 1;
+      // Fields 2 - 7 are only used on the server.
+    }
+    repeated Element element = 1;
+  }
+
+  // This is an OS X only message to report extended attribute informations.
+  // Extended attributes on OS X are used for various security mechanisms,
+  // which makes them interesting to Chrome.
+  message ExtendedAttr {
+    // This is the name of the extended attribute.
+    required string key = 1;
+    // This is the value of the extended attribute.
+    optional bytes value = 2;
+  }
+
+  message SignatureInfo {
+    // All certificate chains for each of the binary's signers.  Multiple chains
+    // may be present if the binary or any certificate has multiple signers.
+    // Absence of certificate chains does not imply that the binary is not
+    // signed (in that case, SignedData blobs extracted from the binary may be
+    // preset), but does mean that trust has not been verified.
+    repeated CertificateChain certificate_chain = 1;
+
+    // True if the signature was trusted on the client.
+    optional bool trusted = 2;
+
+    // On Windows, PKCS#7 SignedData blobs extracted from a portable executable
+    // image's attribute certificate table. The presence of these does not imply
+    // that the signatures were deemed trusted by the client.
+    // On Mac, this is the code signature blob referenced by the
+    // LC_CODE_SIGNATURE load command.
+    repeated bytes signed_data = 3;
+
+    // On OS X, code signing data can be contained in the extended attributes of
+    // a file. As Gatekeeper respects this signature, we look for it and collect
+    // it.
+    repeated ExtendedAttr xattr = 4;
+  }
+
+  // This field will only be set if the binary is signed.
+  optional SignatureInfo signature = 5;
+
+  // True if the download was user initiated.
+  optional bool user_initiated = 6;
+
+  // Fields 7 and 8 are only used on the server.
+
+  // Name of the file where the download would be stored if the
+  // download completes.  E.g., "bla.exe".
+  optional string file_basename = 9;
+
+  // Starting with Chrome M19 we're also sending back pings for Chrome
+  // extensions that get downloaded by users.
+  enum DownloadType {
+    WIN_EXECUTABLE = 0;    // Currently all .exe, .cab and .msi files.
+    CHROME_EXTENSION = 1;  // .crx files.
+    ANDROID_APK = 2;       // .apk files.
+    // .zip files containing one of the other executable types.
+    ZIPPED_EXECUTABLE = 3;
+    MAC_EXECUTABLE = 4;  // .dmg, .pkg, etc.
+    ZIPPED_ARCHIVE = 5;  // .zip file containing another archive.
+    ARCHIVE = 6;         // Archive that doesn't have a specific DownloadType.
+    // A .zip that Chrome failed to unpack to the point of finding exe/zips.
+    INVALID_ZIP = 7;
+    // A .dmg, .pkg, etc, that Chrome failed to unpack to the point of finding
+    // Mach O's.
+    INVALID_MAC_ARCHIVE = 8;
+    // A download request initiated via PPAPI. Typically the requestor is
+    // a Flash applet.
+    PPAPI_SAVE_REQUEST = 9;
+    // A file we don't support, but we've decided to sample and send
+    // a light-ping.
+    SAMPLED_UNSUPPORTED_FILE = 10;
+  }
+  optional DownloadType download_type = 10 [default = WIN_EXECUTABLE];
+
+  // Locale of the device, eg en, en_US.
+  optional string locale = 11;
+
+  message PEImageHeaders {
+    // IMAGE_DOS_HEADER.
+    optional bytes dos_header = 1;
+    // IMAGE_FILE_HEADER.
+    optional bytes file_header = 2;
+    // IMAGE_OPTIONAL_HEADER32. Present only for 32-bit PE images.
+    optional bytes optional_headers32 = 3;
+    // IMAGE_OPTIONAL_HEADER64. Present only for 64-bit PE images.
+    optional bytes optional_headers64 = 4;
+    // IMAGE_SECTION_HEADER.
+    repeated bytes section_header = 5;
+    // Contents of the .edata section.
+    optional bytes export_section_data = 6;
+
+    message DebugData {
+      // IMAGE_DEBUG_DIRECTORY.
+      optional bytes directory_entry = 1;
+      optional bytes raw_data = 2;
+    }
+
+    repeated DebugData debug_data = 7;
+  }
+
+  message MachOHeaders {
+    // The mach_header or mach_header_64 struct.
+    required bytes mach_header = 1;
+
+    message LoadCommand {
+      // |command_id| is the first uint32 of |command| as well, but is
+      // extracted for easier processing.
+      required uint32 command_id = 1;
+      // The entire data stream of the load command.
+      required bytes command = 2;
+    }
+
+    // All the load commands of the Mach-O file.
+    repeated LoadCommand load_commands = 2;
+  }
+
+  message ImageHeaders {
+    // Windows Portable Executable image headers.
+    optional PEImageHeaders pe_headers = 1;
+
+    // OS X Mach-O image headers.
+    repeated MachOHeaders mach_o_headers = 2;
+  };
+
+  // Fields 12-17 are reserved for server-side use and are never sent by the
+  // client.
+
+  optional ImageHeaders image_headers = 18;
+
+  // Fields 19-21 are reserved for server-side use and are never sent by the
+  // client.
+
+  // A binary or archive contained in an archive (e.g., a .exe in a .zip
+  // archive, or a .zip inside a .zip).
+  message ArchivedBinary {
+    optional string file_basename = 1;
+    optional DownloadType download_type = 2;
+    optional Digests digests = 3;
+    optional int64 length = 4;
+    optional SignatureInfo signature = 5;
+    optional ImageHeaders image_headers = 6;
+  }
+
+  repeated ArchivedBinary archived_binary = 22;
+
+  // Population that the reporting user is part of.
+  optional ChromeUserPopulation population = 24;
+
+  // True if the .zip or DMG, etc, was 100% successfully unpacked.
+  optional bool archive_valid = 26;
+
+  // True if this ClientDownloadRequest is from a whitelisted domain.
+  optional bool skipped_url_whitelist = 28;
+
+  // True if this ClientDownloadRequest contains a whitelisted certificate.
+  optional bool skipped_certificate_whitelist = 31;
+
+  // PPAPI_SAVE_REQUEST type messages may have more than one suggested filetype.
+  // Each element in this collection indicates an alternate extension including
+  // the leading extension separator.
+  repeated string alternate_extensions = 35;
+
+  // URLs transitions from landing referrer to download in reverse chronological
+  // order, i.e. download url comes first in this list, and landing referrer
+  // comes last.
+  repeated ReferrerChainEntry referrer_chain = 36;
+
+  // Deprecated.
+  optional bool DEPRECATED_download_attribution_finch_enabled = 39
+      [deprecated = true];
+
+  // The Mac disk image code signature.
+  // The underlying structure of code signature is defined at
+  // https://opensource.apple.com/source/xnu/xnu-2782.1.97/bsd/sys/codesign.h
+  optional bytes udif_code_signature = 40;
+}
+
+// Please update SafeBrowsingNavigationObserverManager::SanitizeReferrerChain()
+// if you're adding more fields to this message.
+message ReferrerChainEntry {
+  enum URLType {
+    // URL of safe browsing events that are at the end of the referrer chain.
+    // e.g. URL of a download, URL of a low reputation login page, etc.
+    EVENT_URL = 1;  // e.g.
+
+    // Landing page is the page user directly interacts with to trigger the
+    // above event, e.g. the page where user clicks a download button.
+    LANDING_PAGE = 2;
+
+    // Landing referrer is the one user directly interacts with right before
+    // navigating to the landing page.
+    LANDING_REFERRER = 3;
+
+    // Client redirect refers to committed navigation between landing page and
+    // the targeted event, or between landing referrer page and landing page.
+    // Client redirect is not triggered by user gesture.
+    CLIENT_REDIRECT = 4;
+
+    DEPRECATED_SERVER_REDIRECT = 5;  // Deprecated
+  }
+
+  message ServerRedirect {
+    // [required] server redirect url
+    optional string url = 1;
+
+    // Additional fields for future expansion.
+  }
+
+  // [required] The url of this Entry.
+  optional string url = 1;
+
+  // Only set if it is different from |url|.
+  optional string main_frame_url = 9;
+
+  // Type of URLs, such as event url, landing page, etc.
+  optional URLType type = 2 [default = CLIENT_REDIRECT];
+
+  // IP addresses corresponding to this host.
+  repeated string ip_addresses = 3;
+
+  // Referrer url of this entry.
+  optional string referrer_url = 4;
+
+  // Main frame URL of referrer.
+  // Only set if it is different from |referrer_url|.
+  optional string referrer_main_frame_url = 5;
+
+  // If this URL loads in a different tab/frame from previous one.
+  optional bool is_retargeting = 6;
+
+  optional double navigation_time_msec = 7;
+
+  // Set only if server redirects happened in navigation.
+  // The first entry in |server_redirect_chain| should be the original request
+  // url, and the last entry should be the same as |url|.
+  repeated ServerRedirect server_redirect_chain = 8;
+}  // End of ReferrerChainEntry
+
+message ClientDownloadResponse {
+  enum Verdict {
+    // Download is considered safe.
+    SAFE = 0;
+    // Download is considered dangerous.  Chrome should show a warning to the
+    // user.
+    DANGEROUS = 1;
+    // Download is uncommon.  Chrome should display a less severe warning.
+    UNCOMMON = 2;
+    // The download is potentially unwanted.
+    POTENTIALLY_UNWANTED = 3;
+    // The download is from a dangerous host.
+    DANGEROUS_HOST = 4;
+    // The backend doesn't have confidence in its verdict of this file.
+    // Chrome should show the default warning if configured for this file type.
+    UNKNOWN = 5;
+  }
+  optional Verdict verdict = 1 [default = SAFE];
+
+  message MoreInfo {
+    // A human-readable string describing the nature of the warning.
+    // Only if verdict != SAFE. Localized based on request.locale.
+    optional string description = 1;
+
+    // A URL to get more information about this warning, if available.
+    optional string url = 2;
+  }
+  optional MoreInfo more_info = 2;
+
+  // An arbitrary token that should be sent along for further server requests.
+  optional bytes token = 3;
+
+  // Whether the server requests that this binary be uploaded.
+  optional bool upload = 5;
+}
+
+// The following protocol buffer holds the feedback report gathered
+// from the user regarding the download.
+message ClientDownloadReport {
+  // The information of user who provided the feedback.
+  // This is going to be useful for handling appeals.
+  message UserInformation { optional string email = 1; }
+
+  enum Reason {
+    SHARE = 0;
+    FALSE_POSITIVE = 1;
+    APPEAL = 2;
+  }
+
+  // The type of feedback for this report.
+  optional Reason reason = 1;
+
+  // The original download ping
+  optional ClientDownloadRequest download_request = 2;
+
+  // Stores the information of the user who provided the feedback.
+  optional UserInformation user_information = 3;
+
+  // Unstructed comments provided by the user.
+  optional bytes comment = 4;
+
+  // The original download response sent from the verdict server.
+  optional ClientDownloadResponse download_response = 5;
+}
+
+// This is used to send back upload status to the client after upload completion
+message ClientUploadResponse {
+  enum UploadStatus {
+    // The upload was successful and a complete response can be expected
+    SUCCESS = 0;
+
+    // The upload was unsuccessful and the response is incomplete.
+    UPLOAD_FAILURE = 1;
+  }
+
+  // Holds the upload status
+  optional UploadStatus status = 1;
+
+  // Holds the permalink where the results of scanning the binary are available
+  optional string permalink = 2;
+}
+
+message ClientIncidentReport {
+  message IncidentData {
+    message TrackedPreferenceIncident {
+      enum ValueState {
+        UNKNOWN = 0;
+        CLEARED = 1;
+        WEAK_LEGACY_OBSOLETE = 2;
+        CHANGED = 3;
+        UNTRUSTED_UNKNOWN_VALUE = 4;
+        BYPASS_CLEARED = 5;
+        BYPASS_CHANGED = 6;
+      }
+
+      optional string path = 1;
+      optional string atomic_value = 2;
+      repeated string split_key = 3;
+      optional ValueState value_state = 4;
+    }
+
+    message BinaryIntegrityIncident {
+      optional string file_basename = 1;
+      optional ClientDownloadRequest.SignatureInfo signature = 2;
+      optional ClientDownloadRequest.ImageHeaders image_headers = 3;
+      optional int32 sec_error = 4;
+
+      message ContainedFile {
+        optional string relative_path = 1;
+        optional ClientDownloadRequest.SignatureInfo signature = 2;
+        optional ClientDownloadRequest.ImageHeaders image_headers = 3;
+      }
+      repeated ContainedFile contained_file = 5;
+    }
+
+    message ResourceRequestIncident {
+      enum Type {
+        UNKNOWN = 0;
+        TYPE_PATTERN = 3;
+      }
+      optional bytes digest = 1;
+      optional string origin = 2;
+      optional Type type = 3 [default = UNKNOWN];
+    }
+
+    optional int64 incident_time_msec = 1;
+    optional TrackedPreferenceIncident tracked_preference = 2;
+    optional BinaryIntegrityIncident binary_integrity = 3;
+    // Note: skip tag 4,5,6 because they were previously used.
+    reserved 4 to 6;
+    optional ResourceRequestIncident resource_request = 7;
+    // Note: skip tag 8 because it was previously used.
+    reserved 8;
+  }
+
+  repeated IncidentData incident = 1;
+
+  message DownloadDetails {
+    optional bytes token = 1;
+    optional ClientDownloadRequest download = 2;
+    optional int64 download_time_msec = 3;
+    optional int64 open_time_msec = 4;
+  }
+
+  optional DownloadDetails download = 2;
+
+  message EnvironmentData {
+    message OS {
+      optional string os_name = 1;
+      optional string os_version = 2;
+
+      message RegistryValue {
+        optional string name = 1;
+        optional uint32 type = 2;
+        optional bytes data = 3;
+      }
+
+      message RegistryKey {
+        optional string name = 1;
+        repeated RegistryValue value = 2;
+        repeated RegistryKey key = 3;
+      }
+
+      repeated RegistryKey registry_key = 3;
+
+      optional bool is_enrolled_to_domain = 4;
+    }
+    optional OS os = 1;
+    message Machine {
+      optional string cpu_architecture = 1;
+      optional string cpu_vendor = 2;
+      optional uint32 cpuid = 3;
+    }
+    optional Machine machine = 2;
+    message Process {
+      optional string version = 1;
+      repeated string OBSOLETE_dlls = 2;
+      message Patch {
+        optional string function = 1;
+        optional string target_dll = 2;
+      }
+      repeated Patch patches = 3;
+      message NetworkProvider {}
+      repeated NetworkProvider network_providers = 4;
+      enum Channel {
+        CHANNEL_UNKNOWN = 0;
+        CHANNEL_CANARY = 1;
+        CHANNEL_DEV = 2;
+        CHANNEL_BETA = 3;
+        CHANNEL_STABLE = 4;
+      }
+      optional Channel chrome_update_channel = 5;
+      optional int64 uptime_msec = 6;
+      optional bool metrics_consent = 7;
+      // Obsolete: extended consent is now required for incident reporting.
+      optional bool OBSOLETE_extended_consent = 8;
+      message Dll {
+        enum Feature {
+          UNKNOWN = 0;
+          LSP = 1;
+        }
+        optional string path = 1;
+        optional uint64 base_address = 2;
+        optional uint32 length = 3;
+        repeated Feature feature = 4;
+        optional ClientDownloadRequest.ImageHeaders image_headers = 5;
+      }
+      repeated Dll dll = 9;
+      repeated string blacklisted_dll = 10;
+      message ModuleState {
+        enum ModifiedState {
+          UNKNOWN = 0;
+          MODULE_STATE_UNKNOWN = 1;
+          MODULE_STATE_UNMODIFIED = 2;
+          MODULE_STATE_MODIFIED = 3;
+        }
+        optional string name = 1;
+        optional ModifiedState modified_state = 2;
+        repeated string OBSOLETE_modified_export = 3;
+
+        message Modification {
+          optional uint32 file_offset = 1;
+          optional int32 byte_count = 2;
+          optional bytes modified_bytes = 3;
+          optional string export_name = 4;
+        }
+        repeated Modification modification = 4;
+      }
+      repeated ModuleState module_state = 11;
+      // Obsolete: field trials no longer enable incident reporting.
+      optional bool OBSOLETE_field_trial_participant = 12;
+    }
+    optional Process process = 3;
+  }
+
+  message ExtensionData {
+    message ExtensionInfo {
+      enum ExtensionState {
+        STATE_UNKNOWN = 0;
+        STATE_ENABLED = 1;
+        STATE_DISABLED = 2;
+        STATE_BLACKLISTED = 3;
+        STATE_BLOCKED = 4;
+        STATE_TERMINATED = 5;
+      }
+
+      optional string id = 1;
+      optional string version = 2;
+      optional string name = 3;
+      optional string description = 4;
+      optional ExtensionState state = 5 [default = STATE_UNKNOWN];
+      optional int32 type = 6;
+      optional string update_url = 7;
+      optional bool has_signature_validation = 8;
+      optional bool signature_is_valid = 9;
+      optional bool installed_by_custodian = 10;
+      optional bool installed_by_default = 11;
+      optional bool installed_by_oem = 12;
+      optional bool from_bookmark = 13;
+      optional bool from_webstore = 14;
+      optional bool converted_from_user_script = 15;
+      optional bool may_be_untrusted = 16;
+      optional int64 install_time_msec = 17;
+      optional int32 manifest_location_type = 18;
+      optional string manifest = 19;
+    }
+
+    optional ExtensionInfo last_installed_extension = 1;
+  }
+
+  optional EnvironmentData environment = 3;
+
+  // Population that the reporting user is part of.
+  optional ChromeUserPopulation population = 7;
+
+  optional ExtensionData extension_data = 8;
+
+  message NonBinaryDownloadDetails {
+    optional string file_type = 1;
+    optional bytes url_spec_sha256 = 2;
+    optional string host = 3;
+    optional int64 length = 4;
+  }
+
+  optional NonBinaryDownloadDetails non_binary_download = 9;
+}
+
+message ClientIncidentResponse {
+  optional bytes token = 1;
+  optional bool download_requested = 2;
+
+  message EnvironmentRequest { optional int32 dll_index = 1; }
+
+  repeated EnvironmentRequest environment_requests = 3;
+}
+
+message DownloadMetadata {
+  optional uint32 download_id = 1;
+
+  optional ClientIncidentReport.DownloadDetails download = 2;
+}
+
+// A Detailed Safebrowsing Report from clients. Chrome safebrowsing reports are
+// only sent by Chrome users who have opted into extended Safe Browsing.
+// This proto is replacing ClientMalwareReportRequest.
+// Next tag: 19
+message ClientSafeBrowsingReportRequest {
+  // Note: A lot of the "optional" fields would make sense to be
+  // "required" instead.  However, having them as optional allows the
+  // clients to send "stripped down" versions of the message in the
+  // future, if we want to.
+
+  enum ReportType {
+    UNKNOWN = 0;
+    URL_PHISHING = 1;
+    URL_MALWARE = 2;
+    URL_UNWANTED = 3;
+    URL_CLIENT_SIDE_PHISHING = 4;
+    URL_CLIENT_SIDE_MALWARE = 5;
+    DANGEROUS_DOWNLOAD_RECOVERY = 6;
+    DANGEROUS_DOWNLOAD_WARNING = 7;
+    DANGEROUS_DOWNLOAD_BY_API = 10;
+    URL_PASSWORD_PROTECTION_PHISHING = 12;
+    DANGEROUS_DOWNLOAD_OPENED = 13;
+    AD_SAMPLE = 14;
+  }
+
+  message HTTPHeader {
+    required bytes name = 1;
+    optional bytes value = 2;
+  }
+
+  message HTTPRequest {
+    message FirstLine {
+      optional bytes verb = 1;
+      optional bytes uri = 2;
+      optional bytes version = 3;
+    }
+
+    optional FirstLine firstline = 1;
+    repeated HTTPHeader headers = 2;
+    optional bytes body = 3;
+
+    // bodydigest and bodylength can be useful if the report does not
+    // contain the body itself.
+    optional bytes bodydigest = 4;  // 32-byte hex md5 digest of body.
+    optional int32 bodylength = 5;  // length of body.
+  }
+
+  message HTTPResponse {
+    message FirstLine {
+      optional int32 code = 1;
+      optional bytes message = 2;
+      optional bytes version = 3;
+    }
+
+    optional FirstLine firstline = 1;
+    repeated HTTPHeader headers = 2;
+    optional bytes body = 3;
+    optional bytes bodydigest = 4;  // 32-byte hex md5 digest of body.
+    optional int32 bodylength = 5;  // length of body.
+    optional bytes remote_ip = 6;   // IP of the server.
+  }
+
+  message Resource {
+    required int32 id = 1;
+    optional string url = 2;
+    optional HTTPRequest request = 3;
+    optional HTTPResponse response = 4;
+    optional int32 parent_id = 5;
+    repeated int32 child_ids = 6;
+    optional string tag_name = 7;
+  }
+
+  optional ReportType type = 10;
+
+  // Only set if ReportType is DANGEROUS_DOWNLOAD_RECOVERY,
+  // DANGEROUS_DOWNLOAD_WARNING or DANGEROUS_DOWNLOAD_BY_API.
+  optional ClientDownloadResponse.Verdict download_verdict = 11;
+
+  // URL of the page in the address bar.
+  optional string url = 1;
+  optional string page_url = 2;
+  optional string referrer_url = 3;
+
+  repeated Resource resources = 4;
+
+  // Contains the hierarchy of elements on the page (ie: the DOM). Some
+  // elements can be Resources and will refer to the resources list (above).
+  repeated HTMLElement dom = 16;
+
+  // Whether the report is complete.
+  optional bool complete = 5;
+
+  // The ASN and country of the client IP. These fields are filled up by
+  // csd_frontend
+  repeated string client_asn = 6;
+  optional string client_country = 7;
+
+  // Whether user chose to proceed.
+  optional bool did_proceed = 8;
+
+  // Whether user visited this origin before.
+  optional bool repeat_visit = 9;
+
+  // The same token in ClientDownloadResponse or LoginReputationClientResponse.
+  // This field is only set if its report type is DANGEROUS_DOWNLOAD_RECOVERY,
+  // DANGEROUS_DOWNLOAD_WARNING, DANGEROUS_DOWNLOAD_BY_API,
+  // URL_PASSWORD_PROTECTION_PHISHING, or DANGEROUS_DOWNLOAD_OPENED.
+  optional bytes token = 15;
+
+  enum SafeBrowsingUrlApiType {
+    SAFE_BROWSING_URL_API_TYPE_UNSPECIFIED = 0;
+    // Native implementation of Safe Browsing API v3 protocol.
+    PVER3_NATIVE = 1;
+    // Native implementation of Safe Browsing API v4 protocol.
+    PVER4_NATIVE = 2;
+    // Android SafetyNet API.
+    // https://developer.android.com/training/safetynet/safebrowsing.html
+    ANDROID_SAFETYNET = 3;
+    // Flywheel (data compression service).
+    FLYWHEEL = 4;
+  }
+
+  // The information propagated from the client about various environment
+  // variables including SDK version, Google Play Services version and so on.
+  message SafeBrowsingClientProperties {
+    optional string client_version = 1;
+    optional int64 google_play_services_version = 2;
+    optional bool is_instant_apps = 3;
+    optional SafeBrowsingUrlApiType url_api_type = 4;
+  }
+  optional SafeBrowsingClientProperties client_properties = 17;
+
+  // Only set if report type is DANGEROUS_DOWNLOAD_EXECUTION.
+  // True means user opened the folder where this download is in via browser.
+  // False means user directly executed this download via download shelf or
+  // other download UIs.
+  optional bool show_download_in_folder = 18;
+}
+
+// An HTML Element on the page (eg: iframe, div, script, etc).
+message HTMLElement {
+  // Id of this element.
+  optional int32 id = 1;
+
+  // The tag type of this element (eg: iframe, div, script, etc).
+  optional string tag = 2;
+
+  // IDs of elements that are children of this element.
+  repeated int32 child_ids = 3;
+
+  // If this element represents a Resource then this is the id of the
+  // Resource, which contains additional data about the Resource. Otherwise
+  // unset.
+  optional int32 resource_id = 5;
+
+  // An Attribute of the element (eg: id, border, foo etc) and its value.
+  message Attribute {
+    optional string name = 1;
+    optional string value = 2;
+  }
+  repeated Attribute attribute = 6;
+}
+
+// Canonical representation of raster image data.
+message ImageData {
+  // Image bitmap, after downscaling to <= 512x512.
+  optional bytes data = 1;
+
+  // Encoding scheme for the bitmap.
+  optional string mime_type = 2;
+
+  message Dimensions {
+    optional int32 width = 1;
+    optional int32 height = 2;
+  }
+
+  // Dimensions of the image stored in |data|.
+  optional Dimensions dimensions = 3;
+  optional Dimensions original_dimensions = 4;  // iff downscaled
+}
+
+// Reporting protobuf for an image served as part of a browser notification.
+// There is no response (an empty body) to this request.
+message NotificationImageReportRequest {
+  optional string notification_origin = 1;  // Src-origin of the notification.
+  optional ImageData image = 2;             // The bitmap of the image.
+
+  // Note that the image URL is deliberately omitted as it would be untrusted,
+  // since the notification image fetch may be intercepted by a Service Worker
+  // (even if the image URL is cross-origin). Otherwise a website could mislead
+  // Safe Browsing into associating phishing image bitmaps with safe image URLs.
+}
diff --git a/toolkit/components/reputationservice/generate_csd.sh b/toolkit/components/reputationservice/generate_csd.sh
new file mode 100755
index 0000000000..7b9d6ddaf5
--- /dev/null
+++ b/toolkit/components/reputationservice/generate_csd.sh
@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+
+# A script to generate
+# chromium/chrome/common/safe_browsing/csd.pb.{cc,h} for use in
+# nsIApplicationReputationQuery. This script assumes you have
+# downloaded and installed the protocol buffer compiler.
+
+set -e
+
+if [ "${PROTOC_PATH:+set}" != "set" ]; then
+  PROTOC_PATH=/usr/local/bin/protoc
+fi
+
+echo "Using $PROTOC_PATH as protocol compiler"
+
+if [ ! -e $PROTOC_PATH ]; then
+  echo "You must install the protocol compiler from " \
+       "https://github.com/google/protobuf/releases"
+  exit 1
+fi
+
+if [ ! -f nsIApplicationReputation.idl ]; then
+    echo "You must run this script in the toolkit/components/reputationservice" >&2
+    echo "directory of the source tree." >&2
+    exit 1
+fi
+
+# Get the protocol buffer and compile it
+CSD_PROTO_URL="https://chromium.googlesource.com/chromium/src/+/main/components/safe_browsing/core/common/proto/csd.proto?format=TEXT"
+CSD_PATH="chromium/chrome/common/safe_browsing"
+
+# Switch to directory with csd.proto before compiling it
+pushd "$CSD_PATH" >/dev/null
+curl "$CSD_PROTO_URL" | base64 --decode > csd.proto
+"$PROTOC_PATH" csd.proto --cpp_out=.
+popd >/dev/null
diff --git a/toolkit/components/reputationservice/moz.build b/toolkit/components/reputationservice/moz.build
new file mode 100644
index 0000000000..1ff235f80a
--- /dev/null
+++ b/toolkit/components/reputationservice/moz.build
@@ -0,0 +1,40 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+with Files("*"):
+    BUG_COMPONENT = ("Toolkit", "Safe Browsing")
+
+XPCSHELL_TESTS_MANIFESTS += ["test/unit/xpcshell.toml"]
+
+EXPORTS.mozilla += ["ApplicationReputation.h"]
+
+XPIDL_SOURCES += [
+    "nsIApplicationReputation.idl",
+]
+
+XPIDL_MODULE = "reputationservice"
+
+UNIFIED_SOURCES += [
+    "ApplicationReputation.cpp",
+    "ApplicationReputationTelemetryUtils.cpp",
+    "chromium/chrome/common/safe_browsing/csd.pb.cc",
+]
+
+FINAL_LIBRARY = "xul"
+
+LOCAL_INCLUDES += [
+    "../protobuf",
+    "/ipc/chromium/src",
+    "chromium",
+]
+
+DEFINES["GOOGLE_PROTOBUF_NO_RTTI"] = True
+DEFINES["GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER"] = True
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+if CONFIG["ENABLE_TESTS"]:
+    DIRS += ["test/gtest"]
diff --git a/toolkit/components/reputationservice/nsIApplicationReputation.idl b/toolkit/components/reputationservice/nsIApplicationReputation.idl
new file mode 100644
index 0000000000..ea7f92038e
--- /dev/null
+++ b/toolkit/components/reputationservice/nsIApplicationReputation.idl
@@ -0,0 +1,147 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIApplicationReputationCallback;
+interface nsIApplicationReputationQuery;
+interface nsIArray;
+interface nsIURI;
+interface nsIReferrerInfo;
+
+/*
+ * A service for asynchronously querying an application reputation service
+ * based on metadata of the downloaded file.
+ */
+[scriptable, uuid(c9f03479-fd68-4393-acb2-c88d4f563174)]
+interface nsIApplicationReputationService : nsISupports {
+  /**
+   * Indicates the reason for the application reputation block.
+   */
+  const unsigned long VERDICT_SAFE = 0;
+  const unsigned long VERDICT_DANGEROUS = 1;
+  const unsigned long VERDICT_UNCOMMON = 2;
+  const unsigned long VERDICT_POTENTIALLY_UNWANTED = 3;
+  const unsigned long VERDICT_DANGEROUS_HOST = 4;
+
+  /**
+   * Start querying the application reputation service.
+   *
+   * @param aQuery
+   *        The nsIApplicationReputationQuery containing metadata of the
+   *        downloaded file.
+   *
+   * @param aCallback
+   *        The callback for receiving the results of the query.
+   *
+   * @remarks aCallback may not be null.  onComplete is guaranteed to be called
+   *          on aCallback. This function may not be called more than once with
+   *          the same query object. If any of the attributes of aQuery have
+   *          not been set or have been set with empty data (with the exception
+   *          of sourceURI), then a valid request can still be constructed and
+   *          will solicit a valid response, but won't produce any useful
+   *          information.
+   */
+  void queryReputation(in nsIApplicationReputationQuery aQuery,
+                       in nsIApplicationReputationCallback aCallback);
+
+  /**
+   * Check if a file with this name should be treated as a binary executable,
+   * and is therefore subject to application reputation checks.
+   * Will return true if the filename's extension is either:
+   * - in kBinaryFileExtensions in ApplicationReputation.cpp
+   * - in sExecutableExts in nsLocalFileCommon.h *and* not in
+   *   kNonBinaryExecutables in ApplicationReputation.cpp
+   *
+   * @param aFilename
+   *        The filename to check.
+   */
+  bool isBinary(in AUTF8String aFilename);
+
+  /**
+   * Check if a file with this name should be treated as an executable,
+   * and should not be opened without caution.
+   * Will return true if the filename's extension is in sExecutableExts
+   * in nsLocalFileCommon.h.
+   *
+   * @param aFilename
+   *        The filename to check.
+   */
+  bool isExecutable(in AUTF8String aFilename);
+};
+
+/**
+ * A single-use, write-once interface for recording the metadata of the
+ * downloaded file. nsIApplicationReputationService.Start() may only be called
+ * once with a single query.
+ */
+[scriptable, uuid(812d7509-a9a3-446e-a66f-3ed8cc91ebd0)]
+interface nsIApplicationReputationQuery : nsISupports {
+  /*
+   * The nsIURI from which the file was downloaded. This may not be null.
+   */
+  readonly attribute nsIURI sourceURI;
+
+  /*
+   * The reference, if any.
+   */
+  readonly attribute nsIReferrerInfo referrerInfo;
+
+  /*
+   * The target filename for the downloaded file, as inferred from the source
+   * URI or provided by the Content-Disposition attachment file name. If this
+   * is not set by the caller, it will be passed as an empty string but the
+   * query won't produce any useful information.
+   */
+  readonly attribute AUTF8String suggestedFileName;
+
+  /*
+   * The size of the downloaded file in bytes.
+   */
+  readonly attribute unsigned long fileSize;
+
+  /*
+   * The SHA256 hash of the downloaded file in raw bytes. If this is not set by
+   * the caller, it will be passed as an empty string but the query won't
+   * produce any useful information.
+   */
+  readonly attribute ACString sha256Hash;
+
+  /*
+   * The Array of Array of Array of bytes that verify for this
+   * binary, if it is signed.
+   */
+  readonly attribute Array<Array<Array<uint8_t> > > signatureInfo;
+
+  /*
+   * The nsIArray of nsIPrincipal of redirects that lead to this download. The
+   * most recent redirect is the last element.
+   */
+  readonly attribute nsIArray redirects;
+};
+
+[scriptable, function, uuid(9a228470-cfe5-11e2-8b8b-0800200c9a66)]
+interface nsIApplicationReputationCallback : nsISupports {
+  /**
+   * Callback for the result of the application reputation query.
+   * @param aStatus
+   *        NS_OK if and only if the query succeeded. If it did, then
+   *        shouldBlock is meaningful (otherwise it defaults to false). This
+   *        may be NS_ERROR_FAILURE if the response cannot be parsed, or
+   *        NS_ERROR_NOT_AVAILABLE if the service has been disabled or is not
+   *        reachable.
+   * @param aShouldBlock
+   *        Whether or not the download should be blocked.
+   * @param aVerdict
+   *        Indicates the result of the lookup that determines whether the
+   *        download should be blocked, according to the "VERDICT_" constants.
+   *        This may be set to a value different than "VERDICT_SAFE" even if
+   *        aShouldBlock is false, so you should always check aShouldBlock.
+   */
+  void onComplete(in bool aShouldBlock,
+                  in nsresult aStatus,
+                  in unsigned long aVerdict);
+};
diff --git a/toolkit/components/reputationservice/test/gtest/TestExecutableLists.cpp b/toolkit/components/reputationservice/test/gtest/TestExecutableLists.cpp
new file mode 100644
index 0000000000..c5fadb62e0
--- /dev/null
+++ b/toolkit/components/reputationservice/test/gtest/TestExecutableLists.cpp
@@ -0,0 +1,385 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/3.0/ */
+
+#include "gtest/gtest.h"
+#include "mozilla/ArrayUtils.h"
+#include "nsLocalFileCommon.h"
+#include "ApplicationReputation.h"
+
+// clang-format off
+// PLEASE read the comment in ApplicationReputation.cpp before modifying this
+// list.
+static const char* const kTestFileExtensions[] = {
+    ".accda",   // MS Access database
+    ".accdb",   // MS Access database
+    ".accde",   // MS Access database
+    ".accdr",   // MS Access database
+    ".action",  // Nac script
+    ".ad",      // Windows (ignored for app rep)
+    ".ade",     // MS Access
+    ".adp",     // MS Access
+    ".afploc",  // Apple Filing Protocol Location (ignored for app rep)
+    ".air",     // Adobe Air (ignored for app rep)
+    ".apk",     // Android package
+    ".app",     // Executable application
+    ".applescript",
+    ".application",  // MS ClickOnce
+    ".appref-ms",    // MS ClickOnce
+    ".appx",
+    ".appxbundle",
+    ".as",           // Mac archive
+    ".asp",          // Windows Server script
+    ".asx",          // Windows Media Player
+    ".atloc",        // Appletalk Location (ignored for app rep)
+    ".bas",          // Basic script
+    ".bash",         // Linux shell
+    ".bat",          // Windows shell
+    ".bin",
+    ".btapp",          // uTorrent and Transmission
+    ".btinstall",      // uTorrent and Transmission
+    ".btkey",          // uTorrent and Transmission
+    ".btsearch",       // uTorrent and Transmission
+    ".btskin",         // uTorrent and Transmission
+    ".bz",             // Linux archive (bzip)
+    ".bz2",            // Linux archive (bzip2)
+    ".bzip2",          // Linux archive (bzip2)
+    ".cab",            // Windows archive
+    ".caction",        // Automator action
+    ".cdr",            // Mac disk image
+    ".cer",            // Signed certificate file
+    ".cfg",            // Windows
+    ".chi",            // Windows Help
+    ".chm",            // Windows Help
+    ".class",          // Java
+    ".cmd",            // Windows executable
+    ".com",            // Windows executable
+    ".command",        // Mac script
+    ".configprofile",  // Configuration file for Apple systems
+    ".cpgz",           // Mac archive
+    ".cpi",            // Control Panel Item. Executable used for adding icons
+                       // to Control Panel
+    ".cpl",            // Windows executable
+    ".crt",            // Windows signed certificate
+    ".crx",            // Chrome extensions
+    ".csh",            // Linux shell
+    ".dart",           // Mac disk image
+    ".dc42",           // Apple DiskCopy Image
+    ".deb",            // Linux package
+    ".definition",     // Automator action
+    ".der",            // Signed certificate file
+    ".desktop",        // A shortcut that runs other files
+    ".dex",            // Android
+    ".dht",            // HTML
+    ".dhtm",           // HTML
+    ".dhtml",          // HTML
+    ".diagcab",        // Windows archive
+    ".diskcopy42",     // Apple DiskCopy Image
+    ".dll",            // Windows executable
+    ".dmg",            // Mac disk image
+    ".dmgpart",        // Mac disk image
+    ".doc",            // MS Office
+    ".docb",           // MS Office
+    ".docm",           // MS Word
+    ".docx",           // MS Word
+    ".dot",            // MS Word
+    ".dotm",           // MS Word
+    ".dott",           // MS Office
+    ".dotx",           // MS Word
+    ".drv",            // Windows driver
+    ".dvdr",           // Mac Disk image
+    ".dylib",          // Mach object dynamic library file
+    ".efi",            // Firmware
+    ".eml",            // MS Outlook
+    ".exe",            // Windows executable
+    ".fileloc",        // Apple finder internet location data file
+    ".fon",            // Windows font
+    ".ftploc",         // Apple FTP Location (ignored for app rep)
+    ".fxp",            // MS FoxPro
+    ".gadget",         // Windows
+    ".grp",            // Windows
+    ".gz",             // Linux archive (gzip)
+    ".gzip",           // Linux archive (gzip)
+    ".hfs",            // Mac disk image
+    ".hlp",            // Windows Help
+    ".hqx",            // Mac archive
+    ".hta",            // HTML trusted application
+    ".htm", ".html",
+    ".htt",                // MS HTML template
+    ".img",                // Mac disk image
+    ".imgpart",            // Mac disk image
+    ".inetloc",            // Apple finder internet location data file
+    ".inf",                // Windows installer
+    ".ini",                // Generic config file
+    ".ins",                // IIS config
+    ".internetconnect",    // Configuration file for Apple system
+    ".iso",                // CD image
+    ".isp",                // IIS config
+    ".jar",                // Java
+#ifndef MOZ_ESR
+    ".jnlp",               // Java
+#endif
+    ".js",                 // JavaScript script
+    ".jse",                // JScript
+    ".ksh",                // Linux shell
+    ".lnk",                // Windows
+    ".local",              // Windows
+    ".mad",                // MS Access
+    ".maf",                // MS Access
+    ".mag",                // MS Access
+    ".mam",                // MS Access
+    ".manifest",           // Windows
+    ".maq",                // MS Access
+    ".mar",                // MS Access
+    ".mas",                // MS Access
+    ".mat",                // MS Access
+    ".mau",                // Media attachment
+    ".mav",                // MS Access
+    ".maw",                // MS Access
+    ".mda",                // MS Access
+    ".mdb",                // MS Access
+    ".mde",                // MS Access
+    ".mdt",                // MS Access
+    ".mdw",                // MS Access
+    ".mdz",                // MS Access
+    ".mht",                // MS HTML
+    ".mhtml",              // MS HTML
+    ".mim",                // MS Mail
+    ".mmc",                // MS Office
+    ".mobileconfig",       // Configuration file for Apple systems
+    ".mof",                // Windows
+    ".mpkg",               // Mac installer
+    ".msc",                // Windows executable
+    ".msg",                // MS Outlook
+    ".msh",                // Windows shell
+    ".msh1",               // Windows shell
+    ".msh1xml",            // Windows shell
+    ".msh2",               // Windows shell
+    ".msh2xml",            // Windows shell
+    ".mshxml",             // Windows
+    ".msi",                // Windows installer
+    ".msix",               // Windows installer
+    ".msixbundle",         // Windows installer
+    ".msp",                // Windows installer
+    ".mst",                // Windows installer
+    ".ndif",               // Mac disk image
+    ".networkconnect",     // Configuration file for Apple system
+    ".ocx",                // ActiveX
+    ".ops",                // MS Office
+    ".osas",               // AppleScript
+    ".osax",               // AppleScript
+    ".oxt",                // OpenOffice extension, can execute arbitrary code
+    ".partial",            // Downloads
+    ".pax",                // Mac archive
+    ".pcd",                // Microsoft Visual Test
+    ".pdf",                // Adobe Acrobat
+    ".pet",                // Linux package
+    ".pif",                // Windows
+    ".pkg",                // Mac installer
+    ".pl",                 // Perl script
+    ".plg",                // MS Visual Studio
+    ".pot",                // MS PowerPoint
+    ".potm",               // MS PowerPoint
+    ".potx",               // MS PowerPoint
+    ".ppam",               // MS PowerPoint
+    ".pps",                // MS PowerPoint
+    ".ppsm",               // MS PowerPoint
+    ".ppsx",               // MS PowerPoint
+    ".ppt",                // MS PowerPoint
+    ".pptm",               // MS PowerPoint
+    ".pptx",               // MS PowerPoint
+    ".prf",                // MS Outlook
+    ".prg",                // Windows
+    ".ps1",                // Windows shell
+    ".ps1xml",             // Windows shell
+    ".ps2",                // Windows shell
+    ".ps2xml",             // Windows shell
+    ".psc1",               // Windows shell
+    ".psc2",               // Windows shell
+    ".pst",                // MS Outlook
+    ".pup",                // Linux package
+    ".py",                 // Python script
+    ".pyc",                // Python binary
+    ".pyd",                // Equivalent of a DLL, for python libraries
+    ".pyo",                // Compiled python code
+    ".pyw",                // Python GUI
+    ".rb",                 // Ruby script
+    ".reg",                // Windows Registry
+    ".rels",               // MS Office
+    ".rpm",                // Linux package
+    ".rtf",                // MS Office
+    ".scf",                // Windows shell
+    ".scpt",               // AppleScript
+    ".scptd",              // AppleScript
+    ".scr",                // Windows
+    ".sct",                // Windows shell
+    ".search-ms",          // Windows
+    ".seplugin",           // AppleScript
+    ".service",            // Systemd service unit file
+    ".settingcontent-ms",  // Windows settings
+    ".sh",                 // Linux shell
+    ".shar",               // Linux shell
+    ".shb",                // Windows
+    ".shs",                // Windows shell
+    ".sht",                // HTML
+    ".shtm",               // HTML
+    ".shtml",              // HTML
+    ".sldm",               // MS PowerPoint
+    ".sldx",               // MS PowerPoint
+    ".slk",                // MS Excel
+    ".slp",                // Linux package
+    ".smi",                // Mac disk image
+    ".sparsebundle",       // Mac disk image
+    ".sparseimage",        // Mac disk image
+    ".spl",                // Adobe Flash
+    ".svg",
+    ".swf",       // Adobe Flash
+    ".swm",       // Windows Imaging
+    ".sys",       // Windows
+    ".tar",       // Linux archive
+    ".taz",       // Linux archive (bzip2)
+    ".tbz",       // Linux archive (bzip2)
+    ".tbz2",      // Linux archive (bzip2)
+    ".tcsh",      // Linux shell
+    ".tgz",       // Linux archive (gzip)
+    ".torrent",   // Bittorrent
+    ".tpz",       // Linux archive (gzip)
+    ".txz",       // Linux archive (xz)
+    ".tz",        // Linux archive (gzip)
+    ".udf",       // MS Excel
+    ".udif",      // Mac disk image
+    ".url",       // Windows
+    ".vb",        // Visual Basic script
+    ".vbe",       // Visual Basic script
+    ".vbs",       // Visual Basic script
+    ".vdx",       // MS Visio
+    ".vhd",       // Windows virtual hard drive
+    ".vhdx",      // Windows virtual hard drive
+    ".vmdk",      // VMware virtual disk
+    ".vsd",       // MS Visio
+    ".vsdm",      // MS Visio
+    ".vsdx",      // MS Visio
+    ".vsmacros",  // MS Visual Studio
+    ".vss",       // MS Visio
+    ".vssm",      // MS Visio
+    ".vssx",      // MS Visio
+    ".vst",       // MS Visio
+    ".vstm",      // MS Visio
+    ".vstx",      // MS Visio
+    ".vsw",       // MS Visio
+    ".vsx",       // MS Visio
+    ".vtx",       // MS Visio
+    ".webloc",    // MacOS website location file
+    ".website",   // Windows
+    ".wflow",     // Automator action
+    ".wim",       // Windows Imaging
+    ".workflow",  // Mac Automator
+    ".ws",        // Windows script
+    ".wsc",       // Windows script
+    ".wsf",       // Windows script
+    ".wsh",       // Windows script
+    ".xar",       // MS Excel
+    ".xbap",      // XAML Browser Application
+    ".xht", ".xhtm", ".xhtml",
+    ".xip",     // Mac archive
+    ".xla",     // MS Excel
+    ".xlam",    // MS Excel
+    ".xldm",    // MS Excel
+    ".xll",     // MS Excel
+    ".xlm",     // MS Excel
+    ".xls",     // MS Excel
+    ".xlsb",    // MS Excel
+    ".xlsm",    // MS Excel
+    ".xlsx",    // MS Excel
+    ".xlt",     // MS Excel
+    ".xltm",    // MS Excel
+    ".xltx",    // MS Excel
+    ".xlw",     // MS Excel
+    ".xml",     // MS Excel
+    ".xnk",     // MS Exchange
+    ".xrm-ms",  // Windows
+    ".xsd",     // XML schema definition
+    ".xsl",     // XML Stylesheet
+    ".xz",      // Linux archive (xz)
+    ".z",       // InstallShield
+#ifdef XP_WIN   // disable on Mac/Linux, see 1167493
+    ".zip",     // Generic archive
+#endif
+    ".zipx",  // WinZip
+};
+// clang-format on
+
+#define CheckListSorted(_list)                                   \
+  {                                                              \
+    for (size_t i = 1; i < mozilla::ArrayLength(_list); ++i) {   \
+      nsDependentCString str1((_list)[i - 1]);                   \
+      nsDependentCString str2((_list)[i]);                       \
+      EXPECT_LE(Compare(str1, str2), -1)                         \
+          << "Expected " << str1.get() << " to be sorted after " \
+          << str2.get();                                         \
+    }                                                            \
+  }
+
+// First, verify that the 2 lists are both sorted. This helps when checking for
+// duplicates manually, ensures we could start doing more efficient lookups if
+// we felt that was necessary (e.g. if the lists get much bigger), and that it's
+// easy for humans to find things...
+TEST(TestExecutableLists, ListsAreSorted)
+{
+  CheckListSorted(sExecutableExts);
+  CheckListSorted(ApplicationReputationService::kBinaryFileExtensions);
+  CheckListSorted(ApplicationReputationService::kNonBinaryExecutables);
+  CheckListSorted(kTestFileExtensions);
+}
+
+bool _IsInList(const char* ext, const char* const _list[], const size_t len) {
+  nsDependentCString extStr(ext);
+  for (size_t i = 0; i < len; ++i) {
+    if (extStr.EqualsASCII(_list[i])) {
+      return true;
+    }
+  }
+  return false;
+}
+
+#define IsInList(_ext, _list) \
+  _IsInList(_ext, _list, mozilla::ArrayLength(_list))
+
+TEST(TestExecutableLists, NonBinariesInExecutablesList)
+{
+  for (auto nonBinary : ApplicationReputationService::kNonBinaryExecutables) {
+    EXPECT_TRUE(IsInList(nonBinary, sExecutableExts))
+        << "Expected " << nonBinary << " to be part of sExecutableExts list";
+  }
+}
+
+TEST(TestExecutableLists, AllExtensionsInTestList)
+{
+  for (auto ext : ApplicationReputationService::kBinaryFileExtensions) {
+    EXPECT_TRUE(IsInList(ext, kTestFileExtensions))
+        << "Expected binary extension " << ext
+        << " to be listed in the test extension list";
+  }
+
+  for (auto ext : sExecutableExts) {
+    EXPECT_TRUE(IsInList(ext, kTestFileExtensions))
+        << "Expected executable extension " << ext
+        << " to be listed in the test extension list";
+  }
+
+  for (auto ext : ApplicationReputationService::kNonBinaryExecutables) {
+    EXPECT_TRUE(IsInList(ext, kTestFileExtensions))
+        << "Expected non-binary executable extension " << ext
+        << " to be listed in the test extension list";
+  }
+}
+
+TEST(TestExecutableLists, TestListExtensionsExistSomewhere)
+{
+  for (auto ext : kTestFileExtensions) {
+    EXPECT_TRUE(
+        IsInList(ext, ApplicationReputationService::kBinaryFileExtensions) !=
+        IsInList(ext, sExecutableExts))
+        << "Expected test extension " << ext
+        << " to be in exactly one of the other lists.";
+  }
+}
diff --git a/toolkit/components/reputationservice/test/gtest/moz.build b/toolkit/components/reputationservice/test/gtest/moz.build
new file mode 100644
index 0000000000..5ba7445f4a
--- /dev/null
+++ b/toolkit/components/reputationservice/test/gtest/moz.build
@@ -0,0 +1,16 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+LOCAL_INCLUDES += [
+    "../..",
+]
+
+DEFINES["GOOGLE_PROTOBUF_NO_RTTI"] = True
+DEFINES["GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER"] = True
+
+UNIFIED_SOURCES += ["TestExecutableLists.cpp"]
+
+FINAL_LIBRARY = "xul-gtest"
diff --git a/toolkit/components/reputationservice/test/unit/data/block_digest.chunk b/toolkit/components/reputationservice/test/unit/data/block_digest.chunk
new file mode 100644
index 0000000000..34c47c4bb5
--- /dev/null
+++ b/toolkit/components/reputationservice/test/unit/data/block_digest.chunk
@@ -0,0 +1,2 @@
+a:5:32:37
+,AÎJ
,AÎJ„ä8æW´�bbòñ_e‹;OÏÏ„CVù 
\ No newline at end of file
diff --git a/toolkit/components/reputationservice/test/unit/data/digest.chunk b/toolkit/components/reputationservice/test/unit/data/digest.chunk
new file mode 100644
index 0000000000..b1fbb46673
--- /dev/null
+++ b/toolkit/components/reputationservice/test/unit/data/digest.chunk
@@ -0,0 +1,3 @@
+a:5:32:64
+“Ê_Há^˜aÍ7ÂÙ]´=#ÌnmåÃøún‹æo—ÌQ‰÷ãÍ
+‡É@.R0ðD©7Y4±íËퟆËS$³�8
\ No newline at end of file
diff --git a/toolkit/components/reputationservice/test/unit/data/signed_win.exe b/toolkit/components/reputationservice/test/unit/data/signed_win.exe
new file mode 100644
index 0000000000..de3bb40e84
--- /dev/null
+++ b/toolkit/components/reputationservice/test/unit/data/signed_win.exe
diff --git a/toolkit/components/reputationservice/test/unit/head_download_manager.js b/toolkit/components/reputationservice/test/unit/head_download_manager.js
new file mode 100644
index 0000000000..5c415fb7f4
--- /dev/null
+++ b/toolkit/components/reputationservice/test/unit/head_download_manager.js
@@ -0,0 +1,134 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// This file tests the download manager backend
+
+do_get_profile();
+
+var { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+var {
+  HTTP_400,
+  HTTP_401,
+  HTTP_402,
+  HTTP_403,
+  HTTP_404,
+  HTTP_405,
+  HTTP_406,
+  HTTP_407,
+  HTTP_408,
+  HTTP_409,
+  HTTP_410,
+  HTTP_411,
+  HTTP_412,
+  HTTP_413,
+  HTTP_414,
+  HTTP_415,
+  HTTP_417,
+  HTTP_500,
+  HTTP_501,
+  HTTP_502,
+  HTTP_503,
+  HTTP_504,
+  HTTP_505,
+  HttpError,
+  HttpServer,
+} = ChromeUtils.importESModule("resource://testing-common/httpd.sys.mjs");
+
+// List types, this should sync with |enum LIST_TYPES| defined in PendingLookup.
+var ALLOW_LIST = 0;
+var BLOCK_LIST = 1;
+var NO_LIST = 2;
+
+// Allow or block reason, this should sync with |enum Reason| in ApplicationReputation.cpp
+var NotSet = 0;
+var LocalWhitelist = 1;
+var LocalBlocklist = 2;
+var NonBinaryFile = 3;
+var VerdictSafe = 4;
+var VerdictUnknown = 5;
+var VerdictDangerous = 6;
+var VerdictDangerousHost = 7;
+var VerdictUnwanted = 8;
+var VerdictUncommon = 9;
+var VerdictUnrecognized = 10;
+var DangerousPrefOff = 11;
+var DangerousHostPrefOff = 12;
+var UnwantedPrefOff = 13;
+var UncommonPrefOff = 14;
+var NetworkError = 15;
+var RemoteLookupDisabled = 16;
+var InternalError = 17;
+var DPDisabled = 18;
+var MAX_REASON = 19;
+
+function createURI(aObj) {
+  return aObj instanceof Ci.nsIFile
+    ? Services.io.newFileURI(aObj)
+    : Services.io.newURI(aObj);
+}
+
+function add_telemetry_count(telemetry, index, count) {
+  let val = telemetry[index] || 0;
+  telemetry[index] = val + count;
+}
+
+function check_telemetry(aExpectedTelemetry) {
+  // SHOULD_BLOCK = true
+  let shouldBlock = Services.telemetry
+    .getHistogramById("APPLICATION_REPUTATION_SHOULD_BLOCK")
+    .snapshot();
+  let expectedShouldBlock = aExpectedTelemetry.shouldBlock;
+  Assert.equal(shouldBlock.values[1] || 0, expectedShouldBlock);
+
+  let local = Services.telemetry
+    .getHistogramById("APPLICATION_REPUTATION_LOCAL")
+    .snapshot();
+
+  let expectedLocal = aExpectedTelemetry.local;
+  Assert.equal(
+    local.values[ALLOW_LIST] || 0,
+    expectedLocal[ALLOW_LIST] || 0,
+    "Allow list.values don't match"
+  );
+  Assert.equal(
+    local.values[BLOCK_LIST] || 0,
+    expectedLocal[BLOCK_LIST] || 0,
+    "Block list.values don't match"
+  );
+  Assert.equal(
+    local.values[NO_LIST] || 0,
+    expectedLocal[NO_LIST] || 0,
+    "No list.values don't match"
+  );
+
+  let reason = Services.telemetry
+    .getHistogramById("APPLICATION_REPUTATION_REASON")
+    .snapshot();
+  let expectedReason = aExpectedTelemetry.reason;
+
+  for (let i = 0; i < MAX_REASON; i++) {
+    if ((reason.values[i] || 0) != (expectedReason[i] || 0)) {
+      Assert.ok(false, "Allow or Block reason(" + i + ") doesn't match");
+    }
+  }
+}
+
+function get_telemetry_snapshot() {
+  let local = Services.telemetry
+    .getHistogramById("APPLICATION_REPUTATION_LOCAL")
+    .snapshot();
+  let shouldBlock = Services.telemetry
+    .getHistogramById("APPLICATION_REPUTATION_SHOULD_BLOCK")
+    .snapshot();
+  let reason = Services.telemetry
+    .getHistogramById("APPLICATION_REPUTATION_REASON")
+    .snapshot();
+  return {
+    shouldBlock: shouldBlock.values[1] || 0,
+    local: local.values,
+    reason: reason.values,
+  };
+}
diff --git a/toolkit/components/reputationservice/test/unit/test_app_rep.js b/toolkit/components/reputationservice/test/unit/test_app_rep.js
new file mode 100644
index 0000000000..9c381a7beb
--- /dev/null
+++ b/toolkit/components/reputationservice/test/unit/test_app_rep.js
@@ -0,0 +1,571 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { NetUtil } = ChromeUtils.importESModule(
+  "resource://gre/modules/NetUtil.sys.mjs"
+);
+
+const gAppRep = Cc[
+  "@mozilla.org/reputationservice/application-reputation-service;1"
+].getService(Ci.nsIApplicationReputationService);
+
+const ReferrerInfo = Components.Constructor(
+  "@mozilla.org/referrer-info;1",
+  "nsIReferrerInfo",
+  "init"
+);
+
+var gHttpServ = null;
+var gTables = {};
+var gExpectedRemote = false;
+var gExpectedRemoteRequestBody = "";
+
+var whitelistedURI = createURI("http://foo:bar@whitelisted.com/index.htm#junk");
+var exampleURI = createURI("http://user:password@example.com/i.html?foo=bar");
+var exampleReferrerURI = createURI(
+  "http://user:password@example.referrer.com/i.html?foo=bar"
+);
+var exampleRedirectURI = createURI(
+  "http://user:password@example.redirect.com/i.html?foo=bar"
+);
+var blocklistedURI = createURI("http://baz:qux@blocklisted.com?xyzzy");
+
+var binaryFile = "binaryFile.exe";
+var nonBinaryFile = "nonBinaryFile.txt";
+
+const appRepURLPref = "browser.safebrowsing.downloads.remote.url";
+
+function createReferrerInfo(
+  aURI,
+  aRefererPolicy = Ci.nsIReferrerInfo.NO_REFERRER
+) {
+  return new ReferrerInfo(aRefererPolicy, true, aURI);
+}
+
+function readFileToString(aFilename) {
+  let f = do_get_file(aFilename);
+  let stream = Cc["@mozilla.org/network/file-input-stream;1"].createInstance(
+    Ci.nsIFileInputStream
+  );
+  stream.init(f, -1, 0, 0);
+  let buf = NetUtil.readInputStreamToString(stream, stream.available());
+  return buf;
+}
+
+// Registers a table for which to serve update chunks. Returns a promise that
+// resolves when that chunk has been downloaded.
+function registerTableUpdate(aTable, aFilename) {
+  // If we haven't been given an update for this table yet, add it to the map
+  if (!(aTable in gTables)) {
+    gTables[aTable] = [];
+  }
+
+  // The number of chunks associated with this table.
+  let numChunks = gTables[aTable].length + 1;
+  let redirectPath = "/" + aTable + "-" + numChunks;
+  let redirectUrl = "localhost:4444" + redirectPath;
+
+  // Store redirect url for that table so we can return it later when we
+  // process an update request.
+  gTables[aTable].push(redirectUrl);
+
+  gHttpServ.registerPathHandler(redirectPath, function (request, response) {
+    info("Mock safebrowsing server handling request for " + redirectPath);
+    let contents = readFileToString(aFilename);
+    info("Length of " + aFilename + ": " + contents.length);
+    response.setHeader(
+      "Content-Type",
+      "application/vnd.google.safebrowsing-update",
+      false
+    );
+    response.setStatusLine(request.httpVersion, 200, "OK");
+    response.bodyOutputStream.write(contents, contents.length);
+  });
+}
+
+add_task(async function test_setup() {
+  // Set up a local HTTP server to return bad verdicts.
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  // Ensure safebrowsing is enabled for this test, even if the app
+  // doesn't have it enabled.
+  Services.prefs.setBoolPref("browser.safebrowsing.malware.enabled", true);
+  Services.prefs.setBoolPref("browser.safebrowsing.downloads.enabled", true);
+  registerCleanupFunction(function () {
+    Services.prefs.clearUserPref("browser.safebrowsing.malware.enabled");
+    Services.prefs.clearUserPref("browser.safebrowsing.downloads.enabled");
+  });
+
+  // Set block and allow tables explicitly, since the allowlist is normally
+  // disabled on non-Windows platforms.
+  Services.prefs.setCharPref(
+    "urlclassifier.downloadBlockTable",
+    "goog-badbinurl-shavar"
+  );
+  Services.prefs.setCharPref(
+    "urlclassifier.downloadAllowTable",
+    "goog-downloadwhite-digest256"
+  );
+  registerCleanupFunction(function () {
+    Services.prefs.clearUserPref("urlclassifier.downloadBlockTable");
+    Services.prefs.clearUserPref("urlclassifier.downloadAllowTable");
+  });
+
+  gHttpServ = new HttpServer();
+  gHttpServ.registerDirectory("/", do_get_cwd());
+  gHttpServ.registerPathHandler("/download", function (request, response) {
+    if (gExpectedRemote) {
+      let body = NetUtil.readInputStreamToString(
+        request.bodyInputStream,
+        request.bodyInputStream.available()
+      );
+      Assert.equal(gExpectedRemoteRequestBody, body);
+    } else {
+      do_throw("This test should never make a remote lookup");
+    }
+  });
+  gHttpServ.start(4444);
+
+  registerCleanupFunction(function () {
+    return (async function () {
+      await new Promise(resolve => {
+        gHttpServ.stop(resolve);
+      });
+    })();
+  });
+});
+
+add_test(function test_nullSourceURI() {
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.reason, InternalError, 1);
+
+  gAppRep.queryReputation(
+    {
+      // No source URI
+      fileSize: 12,
+    },
+    function onComplete(aShouldBlock, aStatus) {
+      Assert.equal(Cr.NS_ERROR_UNEXPECTED, aStatus);
+      Assert.ok(!aShouldBlock);
+      check_telemetry(expected);
+      run_next_test();
+    }
+  );
+});
+
+add_test(function test_nullCallback() {
+  let expected = get_telemetry_snapshot();
+
+  try {
+    gAppRep.queryReputation(
+      {
+        sourceURI: createURI("http://example.com"),
+        fileSize: 12,
+      },
+      null
+    );
+    do_throw("Callback cannot be null");
+  } catch (ex) {
+    if (ex.result != Cr.NS_ERROR_INVALID_POINTER) {
+      throw ex;
+    }
+    // We don't even increment the count here, because there's no callback.
+    check_telemetry(expected);
+    run_next_test();
+  }
+});
+
+// Set up the local whitelist.
+add_test(function test_local_list() {
+  // Construct a response with redirect urls.
+  function processUpdateRequest() {
+    let response = "n:1000\n";
+    for (let table in gTables) {
+      response += "i:" + table + "\n";
+      for (let i = 0; i < gTables[table].length; ++i) {
+        response += "u:" + gTables[table][i] + "\n";
+      }
+    }
+    info("Returning update response: " + response);
+    return response;
+  }
+  gHttpServ.registerPathHandler("/downloads", function (request, response) {
+    let blob = processUpdateRequest();
+    response.setHeader(
+      "Content-Type",
+      "application/vnd.google.safebrowsing-update",
+      false
+    );
+    response.setStatusLine(request.httpVersion, 200, "OK");
+    response.bodyOutputStream.write(blob, blob.length);
+  });
+
+  let streamUpdater = Cc[
+    "@mozilla.org/url-classifier/streamupdater;1"
+  ].getService(Ci.nsIUrlClassifierStreamUpdater);
+
+  // Load up some update chunks for the safebrowsing server to serve.
+  // This chunk contains the hash of blocklisted.com/.
+  registerTableUpdate("goog-badbinurl-shavar", "data/block_digest.chunk");
+  // This chunk contains the hash of whitelisted.com/.
+  registerTableUpdate("goog-downloadwhite-digest256", "data/digest.chunk");
+
+  // Download some updates, and don't continue until the downloads are done.
+  function updateSuccess(aEvent) {
+    // Timeout of n:1000 is constructed in processUpdateRequest above and
+    // passed back in the callback in nsIUrlClassifierStreamUpdater on success.
+    Assert.equal("1000", aEvent);
+    info("All data processed");
+    run_next_test();
+  }
+  // Just throw if we ever get an update or download error.
+  function handleError(aEvent) {
+    do_throw("We didn't download or update correctly: " + aEvent);
+  }
+  streamUpdater.downloadUpdates(
+    "goog-downloadwhite-digest256,goog-badbinurl-shavar",
+    "goog-downloadwhite-digest256,goog-badbinurl-shavar;\n",
+    true, // isPostRequest.
+    "http://localhost:4444/downloads",
+    updateSuccess,
+    handleError,
+    handleError
+  );
+});
+
+add_test(function test_unlisted() {
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, NonBinaryFile, 1);
+
+  gAppRep.queryReputation(
+    {
+      sourceURI: exampleURI,
+      fileSize: 12,
+    },
+    function onComplete(aShouldBlock, aStatus) {
+      Assert.equal(Cr.NS_OK, aStatus);
+      Assert.ok(!aShouldBlock);
+      check_telemetry(expected);
+      run_next_test();
+    }
+  );
+});
+
+add_test(function test_non_uri() {
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.reason, NonBinaryFile, 1);
+
+  // No listcount is incremented, since the sourceURI is not an nsIURL
+  let source = NetUtil.newURI("data:application/octet-stream,ABC");
+  Assert.equal(false, source instanceof Ci.nsIURL);
+  gAppRep.queryReputation(
+    {
+      sourceURI: source,
+      fileSize: 12,
+    },
+    function onComplete(aShouldBlock, aStatus) {
+      Assert.equal(Cr.NS_OK, aStatus);
+      Assert.ok(!aShouldBlock);
+      check_telemetry(expected);
+      run_next_test();
+    }
+  );
+});
+
+add_test(function test_local_blacklist() {
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  let expected = get_telemetry_snapshot();
+  expected.shouldBlock++;
+  add_telemetry_count(expected.local, BLOCK_LIST, 1);
+  add_telemetry_count(expected.reason, LocalBlocklist, 1);
+
+  gAppRep.queryReputation(
+    {
+      sourceURI: blocklistedURI,
+      fileSize: 12,
+    },
+    function onComplete(aShouldBlock, aStatus) {
+      Assert.equal(Cr.NS_OK, aStatus);
+      Assert.ok(aShouldBlock);
+      check_telemetry(expected);
+
+      run_next_test();
+    }
+  );
+});
+
+add_test(async function test_referer_blacklist() {
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  let testReferrerPolicies = [
+    Ci.nsIReferrerInfo.EMPTY,
+    Ci.nsIReferrerInfo.NO_REFERRER,
+    Ci.nsIReferrerInfo.NO_REFERRER_WHEN_DOWNGRADE,
+    Ci.nsIReferrerInfo.ORIGIN,
+    Ci.nsIReferrerInfo.ORIGIN_WHEN_CROSS_ORIGIN,
+    Ci.nsIReferrerInfo.UNSAFE_URL,
+    Ci.nsIReferrerInfo.SAME_ORIGIN,
+    Ci.nsIReferrerInfo.STRICT_ORIGIN,
+    Ci.nsIReferrerInfo.STRICT_ORIGIN_WHEN_CROSS_ORIGIN,
+  ];
+
+  function runReferrerPolicyTest(referrerPolicy) {
+    return new Promise(resolve => {
+      let expected = get_telemetry_snapshot();
+      expected.shouldBlock++;
+      add_telemetry_count(expected.local, BLOCK_LIST, 1);
+      add_telemetry_count(expected.local, NO_LIST, 1);
+      add_telemetry_count(expected.reason, LocalBlocklist, 1);
+
+      gAppRep.queryReputation(
+        {
+          sourceURI: exampleURI,
+          referrerInfo: createReferrerInfo(blocklistedURI, referrerPolicy),
+          fileSize: 12,
+        },
+        function onComplete(aShouldBlock, aStatus) {
+          Assert.equal(Cr.NS_OK, aStatus);
+          Assert.ok(aShouldBlock);
+          check_telemetry(expected);
+          resolve();
+        }
+      );
+    });
+  }
+
+  // We run tests with referrer policies but download protection should use
+  // "full URL" original referrer to block the download
+  for (let i = 0; i < testReferrerPolicies.length; ++i) {
+    await runReferrerPolicyTest(testReferrerPolicies[i]);
+  }
+
+  run_next_test();
+});
+
+add_test(function test_blocklist_trumps_allowlist() {
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  let expected = get_telemetry_snapshot();
+  expected.shouldBlock++;
+  add_telemetry_count(expected.local, BLOCK_LIST, 1);
+  add_telemetry_count(expected.local, ALLOW_LIST, 1);
+  add_telemetry_count(expected.reason, LocalBlocklist, 1);
+
+  gAppRep.queryReputation(
+    {
+      sourceURI: whitelistedURI,
+      referrerInfo: createReferrerInfo(blocklistedURI),
+      suggestedFileName: binaryFile,
+      fileSize: 12,
+      signatureInfo: [],
+    },
+    function onComplete(aShouldBlock, aStatus) {
+      Assert.equal(Cr.NS_OK, aStatus);
+      Assert.ok(aShouldBlock);
+      check_telemetry(expected);
+
+      run_next_test();
+    }
+  );
+});
+
+add_test(function test_redirect_on_blocklist() {
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  let expected = get_telemetry_snapshot();
+  expected.shouldBlock++;
+  add_telemetry_count(expected.local, BLOCK_LIST, 1);
+  add_telemetry_count(expected.local, ALLOW_LIST, 1);
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, LocalBlocklist, 1);
+  let secman = Services.scriptSecurityManager;
+  let badRedirects = Cc["@mozilla.org/array;1"].createInstance(
+    Ci.nsIMutableArray
+  );
+
+  let redirect1 = {
+    QueryInterface: ChromeUtils.generateQI(["nsIRedirectHistoryEntry"]),
+    principal: secman.createContentPrincipal(exampleURI, {}),
+  };
+  badRedirects.appendElement(redirect1);
+
+  let redirect2 = {
+    QueryInterface: ChromeUtils.generateQI(["nsIRedirectHistoryEntry"]),
+    principal: secman.createContentPrincipal(blocklistedURI, {}),
+  };
+  badRedirects.appendElement(redirect2);
+
+  // Add a whitelisted URI that will not be looked up against the
+  // whitelist (i.e. it will match NO_LIST).
+  let redirect3 = {
+    QueryInterface: ChromeUtils.generateQI(["nsIRedirectHistoryEntry"]),
+    principal: secman.createContentPrincipal(whitelistedURI, {}),
+  };
+  badRedirects.appendElement(redirect3);
+
+  gAppRep.queryReputation(
+    {
+      sourceURI: whitelistedURI,
+      referrerInfo: createReferrerInfo(exampleURI),
+      redirects: badRedirects,
+      suggestedFileName: binaryFile,
+      fileSize: 12,
+      signatureInfo: [],
+    },
+    function onComplete(aShouldBlock, aStatus) {
+      Assert.equal(Cr.NS_OK, aStatus);
+      Assert.ok(aShouldBlock);
+      check_telemetry(expected);
+      run_next_test();
+    }
+  );
+});
+
+add_test(function test_whitelisted_source() {
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, ALLOW_LIST, 1);
+  add_telemetry_count(expected.reason, LocalWhitelist, 1);
+  gAppRep.queryReputation(
+    {
+      sourceURI: whitelistedURI,
+      suggestedFileName: binaryFile,
+      fileSize: 12,
+      signatureInfo: [],
+    },
+    function onComplete(aShouldBlock, aStatus) {
+      Assert.equal(Cr.NS_OK, aStatus);
+      Assert.ok(!aShouldBlock);
+      check_telemetry(expected);
+      run_next_test();
+    }
+  );
+});
+
+add_test(function test_whitelisted_non_binary_source() {
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, NonBinaryFile, 1);
+  gAppRep.queryReputation(
+    {
+      sourceURI: whitelistedURI,
+      suggestedFileName: nonBinaryFile,
+      fileSize: 12,
+    },
+    function onComplete(aShouldBlock, aStatus) {
+      Assert.equal(Cr.NS_OK, aStatus);
+      Assert.ok(!aShouldBlock);
+      check_telemetry(expected);
+      run_next_test();
+    }
+  );
+});
+
+add_test(function test_whitelisted_referrer() {
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 2);
+  add_telemetry_count(expected.reason, NonBinaryFile, 1);
+
+  gAppRep.queryReputation(
+    {
+      sourceURI: exampleURI,
+      referrerInfo: createReferrerInfo(exampleURI),
+      fileSize: 12,
+    },
+    function onComplete(aShouldBlock, aStatus) {
+      Assert.equal(Cr.NS_OK, aStatus);
+      Assert.ok(!aShouldBlock);
+      check_telemetry(expected);
+      run_next_test();
+    }
+  );
+});
+
+add_test(function test_whitelisted_redirect() {
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 3);
+  add_telemetry_count(expected.reason, NonBinaryFile, 1);
+  let secman = Services.scriptSecurityManager;
+  let okayRedirects = Cc["@mozilla.org/array;1"].createInstance(
+    Ci.nsIMutableArray
+  );
+
+  let redirect1 = {
+    QueryInterface: ChromeUtils.generateQI(["nsIRedirectHistoryEntry"]),
+    principal: secman.createContentPrincipal(exampleURI, {}),
+  };
+  okayRedirects.appendElement(redirect1);
+
+  // Add a whitelisted URI that will not be looked up against the
+  // whitelist (i.e. it will match NO_LIST).
+  let redirect2 = {
+    QueryInterface: ChromeUtils.generateQI(["nsIRedirectHistoryEntry"]),
+    principal: secman.createContentPrincipal(whitelistedURI, {}),
+  };
+  okayRedirects.appendElement(redirect2);
+
+  gAppRep.queryReputation(
+    {
+      sourceURI: exampleURI,
+      redirects: okayRedirects,
+      fileSize: 12,
+    },
+    function onComplete(aShouldBlock, aStatus) {
+      Assert.equal(Cr.NS_OK, aStatus);
+      Assert.ok(!aShouldBlock);
+      check_telemetry(expected);
+      run_next_test();
+    }
+  );
+});
+
+add_test(function test_remote_lookup_protocolbuf() {
+  // This long hard-coded string is the contents of the request generated by
+  // the Application Reputation component, converted to the binary protobuf format.
+  // If this test is changed, or we add anything to the remote lookup requests
+  // in ApplicationReputation.cpp, then we'll need to update this hard-coded string.
+  gExpectedRemote = true;
+  gExpectedRemoteRequestBody =
+    "\x0A\x19\x68\x74\x74\x70\x3A\x2F\x2F\x65\x78\x61\x6D\x70\x6C\x65\x2E\x63\x6F\x6D\x2F\x69\x2E\x68\x74\x6D\x6C\x12\x22\x0A\x20\x61\x62\x63\x00\x64\x65\x64\x65\x64\x65\x64\x65\x64\x65\x64\x65\x64\x65\x64\x65\x64\x65\x64\x65\x64\x65\x64\x65\x64\x65\x64\x65\x18\x0C\x22\x41\x0A\x19\x68\x74\x74\x70\x3A\x2F\x2F\x65\x78\x61\x6D\x70\x6C\x65\x2E\x63\x6F\x6D\x2F\x69\x2E\x68\x74\x6D\x6C\x10\x00\x22\x22\x68\x74\x74\x70\x3A\x2F\x2F\x65\x78\x61\x6D\x70\x6C\x65\x2E\x72\x65\x66\x65\x72\x72\x65\x72\x2E\x63\x6F\x6D\x2F\x69\x2E\x68\x74\x6D\x6C\x22\x26\x0A\x22\x68\x74\x74\x70\x3A\x2F\x2F\x65\x78\x61\x6D\x70\x6C\x65\x2E\x72\x65\x64\x69\x72\x65\x63\x74\x2E\x63\x6F\x6D\x2F\x69\x2E\x68\x74\x6D\x6C\x10\x01\x30\x01\x4A\x0E\x62\x69\x6E\x61\x72\x79\x46\x69\x6C\x65\x2E\x65\x78\x65\x50\x00\x5A\x05\x65\x6E\x2D\x55\x53";
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  let secman = Services.scriptSecurityManager;
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 3);
+  add_telemetry_count(expected.reason, VerdictSafe, 1);
+
+  // Redirects
+  let redirects = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
+  let redirect1 = {
+    QueryInterface: ChromeUtils.generateQI(["nsIRedirectHistoryEntry"]),
+    principal: secman.createContentPrincipal(exampleRedirectURI, {}),
+  };
+  redirects.appendElement(redirect1);
+
+  // Insert null(\x00) in the middle of the hash to test we won't truncate it.
+  let sha256Hash = "abc\x00" + "de".repeat(14);
+
+  gAppRep.queryReputation(
+    {
+      sourceURI: exampleURI,
+      referrerInfo: createReferrerInfo(exampleReferrerURI),
+      suggestedFileName: binaryFile,
+      sha256Hash,
+      redirects,
+      fileSize: 12,
+      signatureInfo: [],
+    },
+    function onComplete(aShouldBlock, aStatus) {
+      Assert.equal(Cr.NS_OK, aStatus);
+      Assert.ok(!aShouldBlock);
+      check_telemetry(expected);
+
+      gExpectedRemote = false;
+      run_next_test();
+    }
+  );
+});
diff --git a/toolkit/components/reputationservice/test/unit/test_app_rep_maclinux.js b/toolkit/components/reputationservice/test/unit/test_app_rep_maclinux.js
new file mode 100644
index 0000000000..a89197e8ec
--- /dev/null
+++ b/toolkit/components/reputationservice/test/unit/test_app_rep_maclinux.js
@@ -0,0 +1,340 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Globals
+
+ChromeUtils.defineESModuleGetters(this, {
+  NetUtil: "resource://gre/modules/NetUtil.sys.mjs",
+});
+
+const gAppRep = Cc[
+  "@mozilla.org/reputationservice/application-reputation-service;1"
+].getService(Ci.nsIApplicationReputationService);
+var gStillRunning = true;
+var gTables = {};
+var gHttpServer = null;
+
+const appRepURLPref = "browser.safebrowsing.downloads.remote.url";
+const remoteEnabledPref = "browser.safebrowsing.downloads.remote.enabled";
+
+function readFileToString(aFilename) {
+  let f = do_get_file(aFilename);
+  let stream = Cc["@mozilla.org/network/file-input-stream;1"].createInstance(
+    Ci.nsIFileInputStream
+  );
+  stream.init(f, -1, 0, 0);
+  let buf = NetUtil.readInputStreamToString(stream, stream.available());
+  return buf;
+}
+
+function registerTableUpdate(aTable, aFilename) {
+  // If we haven't been given an update for this table yet, add it to the map
+  if (!(aTable in gTables)) {
+    gTables[aTable] = [];
+  }
+
+  // The number of chunks associated with this table.
+  let numChunks = gTables[aTable].length + 1;
+  let redirectPath = "/" + aTable + "-" + numChunks;
+  let redirectUrl = "localhost:4444" + redirectPath;
+
+  // Store redirect url for that table so we can return it later when we
+  // process an update request.
+  gTables[aTable].push(redirectUrl);
+
+  gHttpServer.registerPathHandler(redirectPath, function (request, response) {
+    info("Mock safebrowsing server handling request for " + redirectPath);
+    let contents = readFileToString(aFilename);
+    info("Length of " + aFilename + ": " + contents.length);
+    response.setHeader(
+      "Content-Type",
+      "application/vnd.google.safebrowsing-update",
+      false
+    );
+    response.setStatusLine(request.httpVersion, 200, "OK");
+    response.bodyOutputStream.write(contents, contents.length);
+  });
+}
+
+// Tests
+
+add_task(function test_setup() {
+  // Wait 10 minutes, that is half of the external xpcshell timeout.
+  do_timeout(10 * 60 * 1000, function () {
+    if (gStillRunning) {
+      do_throw("Test timed out.");
+    }
+  });
+  // Set up a local HTTP server to return bad verdicts.
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  // Ensure safebrowsing is enabled for this test, even if the app
+  // doesn't have it enabled.
+  Services.prefs.setBoolPref("browser.safebrowsing.malware.enabled", true);
+  Services.prefs.setBoolPref("browser.safebrowsing.downloads.enabled", true);
+  // Set block table explicitly, no need for the allow table though
+  Services.prefs.setCharPref(
+    "urlclassifier.downloadBlockTable",
+    "goog-badbinurl-shavar"
+  );
+  // SendRemoteQueryInternal needs locale preference.
+  let originalReqLocales = Services.locale.requestedLocales;
+  Services.locale.requestedLocales = ["en-US"];
+
+  registerCleanupFunction(function () {
+    Services.prefs.clearUserPref("browser.safebrowsing.malware.enabled");
+    Services.prefs.clearUserPref("browser.safebrowsing.downloads.enabled");
+    Services.prefs.clearUserPref("urlclassifier.downloadBlockTable");
+    Services.locale.requestedLocales = originalReqLocales;
+  });
+
+  gHttpServer = new HttpServer();
+  gHttpServer.registerDirectory("/", do_get_cwd());
+
+  function createVerdict(aShouldBlock) {
+    // We can't programmatically create a protocol buffer here, so just
+    // hardcode some already serialized ones.
+    let blob = String.fromCharCode(parseInt(0x08, 16));
+    if (aShouldBlock) {
+      // A safe_browsing::ClientDownloadRequest with a DANGEROUS verdict
+      blob += String.fromCharCode(parseInt(0x01, 16));
+    } else {
+      // A safe_browsing::ClientDownloadRequest with a SAFE verdict
+      blob += String.fromCharCode(parseInt(0x00, 16));
+    }
+    return blob;
+  }
+
+  gHttpServer.registerPathHandler("/throw", function (request, response) {
+    do_throw("We shouldn't be getting here");
+  });
+
+  gHttpServer.registerPathHandler("/download", function (request, response) {
+    info("Querying remote server for verdict");
+    response.setHeader("Content-Type", "application/octet-stream", false);
+    let buf = NetUtil.readInputStreamToString(
+      request.bodyInputStream,
+      request.bodyInputStream.available()
+    );
+    info("Request length: " + buf.length);
+    // A garbage response. By default this produces NS_CANNOT_CONVERT_DATA as
+    // the callback status.
+    let blob =
+      "this is not a serialized protocol buffer (the length doesn't match our hard-coded values)";
+    // We can't actually parse the protocol buffer here, so just switch on the
+    // length instead of inspecting the contents.
+    if (buf.length == 67) {
+      // evil.com
+      blob = createVerdict(true);
+    } else if (buf.length == 73) {
+      // mozilla.com
+      blob = createVerdict(false);
+    }
+    response.bodyOutputStream.write(blob, blob.length);
+  });
+
+  gHttpServer.start(4444);
+
+  registerCleanupFunction(function () {
+    return (async function () {
+      await new Promise(resolve => {
+        gHttpServer.stop(resolve);
+      });
+    })();
+  });
+});
+
+// Construct a response with redirect urls.
+function processUpdateRequest() {
+  let response = "n:1000\n";
+  for (let table in gTables) {
+    response += "i:" + table + "\n";
+    for (let i = 0; i < gTables[table].length; ++i) {
+      response += "u:" + gTables[table][i] + "\n";
+    }
+  }
+  info("Returning update response: " + response);
+  return response;
+}
+
+// Set up the local whitelist.
+function waitForUpdates() {
+  return new Promise((resolve, reject) => {
+    gHttpServer.registerPathHandler("/downloads", function (request, response) {
+      let blob = processUpdateRequest();
+      response.setHeader(
+        "Content-Type",
+        "application/vnd.google.safebrowsing-update",
+        false
+      );
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.bodyOutputStream.write(blob, blob.length);
+    });
+
+    let streamUpdater = Cc[
+      "@mozilla.org/url-classifier/streamupdater;1"
+    ].getService(Ci.nsIUrlClassifierStreamUpdater);
+
+    // Load up some update chunks for the safebrowsing server to serve. This
+    // particular chunk contains the hash of whitelisted.com/ and
+    // sb-ssl.google.com/safebrowsing/csd/certificate/.
+    registerTableUpdate("goog-downloadwhite-digest256", "data/digest.chunk");
+
+    // Resolve the promise once processing the updates is complete.
+    function updateSuccess(aEvent) {
+      // Timeout of n:1000 is constructed in processUpdateRequest above and
+      // passed back in the callback in nsIUrlClassifierStreamUpdater on success.
+      Assert.equal("1000", aEvent);
+      info("All data processed");
+      resolve(true);
+    }
+    // Just throw if we ever get an update or download error.
+    function handleError(aEvent) {
+      do_throw("We didn't download or update correctly: " + aEvent);
+      reject();
+    }
+    streamUpdater.downloadUpdates(
+      "goog-downloadwhite-digest256",
+      "goog-downloadwhite-digest256;\n",
+      true,
+      "http://localhost:4444/downloads",
+      updateSuccess,
+      handleError,
+      handleError
+    );
+  });
+}
+
+function promiseQueryReputation(query, expected) {
+  return new Promise(resolve => {
+    function onComplete(aShouldBlock, aStatus) {
+      Assert.equal(Cr.NS_OK, aStatus);
+      check_telemetry(expected);
+      resolve(true);
+    }
+    gAppRep.queryReputation(query, onComplete);
+  });
+}
+
+add_task(async function () {
+  // Wait for Safebrowsing local list updates to complete.
+  await waitForUpdates();
+});
+
+add_task(async function test_blocked_binary() {
+  // We should reach the remote server for a verdict.
+  Services.prefs.setBoolPref(remoteEnabledPref, true);
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  let expected = get_telemetry_snapshot();
+  expected.shouldBlock++;
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, VerdictDangerous, 1);
+
+  // evil.com should return a malware verdict from the remote server.
+  await promiseQueryReputation(
+    {
+      sourceURI: createURI("http://evil.com"),
+      suggestedFileName: "noop.bat",
+      fileSize: 12,
+      signatureInfo: [],
+    },
+    expected
+  );
+});
+
+add_task(async function test_non_binary() {
+  // We should not reach the remote server for a verdict for non-binary files.
+  Services.prefs.setBoolPref(remoteEnabledPref, true);
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/throw");
+
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, NonBinaryFile, 1);
+
+  await promiseQueryReputation(
+    {
+      sourceURI: createURI("http://evil.com"),
+      suggestedFileName: "noop.txt",
+      fileSize: 12,
+      signatureInfo: [],
+    },
+    expected
+  );
+});
+
+add_task(async function test_good_binary() {
+  // We should reach the remote server for a verdict.
+  Services.prefs.setBoolPref(remoteEnabledPref, true);
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, VerdictSafe, 1);
+
+  // mozilla.com should return a not-guilty verdict from the remote server.
+  await promiseQueryReputation(
+    {
+      sourceURI: createURI("http://mozilla.com"),
+      suggestedFileName: "noop.bat",
+      fileSize: 12,
+      signatureInfo: [],
+    },
+    expected
+  );
+});
+
+add_task(async function test_disabled() {
+  // Explicitly disable remote checks
+  Services.prefs.setBoolPref(remoteEnabledPref, false);
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/throw");
+
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, RemoteLookupDisabled, 1);
+
+  let query = {
+    sourceURI: createURI("http://example.com"),
+    suggestedFileName: "noop.bat",
+    fileSize: 12,
+    signatureInfo: [],
+  };
+  await new Promise(resolve => {
+    gAppRep.queryReputation(query, function onComplete(aShouldBlock, aStatus) {
+      // We should be getting NS_ERROR_NOT_AVAILABLE if the service is disabled
+      Assert.equal(Cr.NS_ERROR_NOT_AVAILABLE, aStatus);
+      Assert.ok(!aShouldBlock);
+      check_telemetry(expected);
+      resolve(true);
+    });
+  });
+});
+
+add_task(async function test_disabled_through_lists() {
+  Services.prefs.setBoolPref(remoteEnabledPref, false);
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  Services.prefs.setCharPref("urlclassifier.downloadBlockTable", "");
+
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, RemoteLookupDisabled, 1);
+
+  let query = {
+    sourceURI: createURI("http://example.com"),
+    suggestedFileName: "noop.bat",
+    fileSize: 12,
+    signatureInfo: [],
+  };
+  await new Promise(resolve => {
+    gAppRep.queryReputation(query, function onComplete(aShouldBlock, aStatus) {
+      // We should be getting NS_ERROR_NOT_AVAILABLE if the service is disabled
+      Assert.equal(Cr.NS_ERROR_NOT_AVAILABLE, aStatus);
+      Assert.ok(!aShouldBlock);
+      check_telemetry(expected);
+      resolve(true);
+    });
+  });
+});
+add_task(async function test_teardown() {
+  gStillRunning = false;
+});
diff --git a/toolkit/components/reputationservice/test/unit/test_app_rep_windows.js b/toolkit/components/reputationservice/test/unit/test_app_rep_windows.js
new file mode 100644
index 0000000000..597810859f
--- /dev/null
+++ b/toolkit/components/reputationservice/test/unit/test_app_rep_windows.js
@@ -0,0 +1,484 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * This file tests signature extraction using Windows Authenticode APIs of
+ * downloaded files.
+ */
+
+// Globals
+
+ChromeUtils.defineESModuleGetters(this, {
+  FileTestUtils: "resource://testing-common/FileTestUtils.sys.mjs",
+  NetUtil: "resource://gre/modules/NetUtil.sys.mjs",
+});
+
+const BackgroundFileSaverOutputStream = Components.Constructor(
+  "@mozilla.org/network/background-file-saver;1?mode=outputstream",
+  "nsIBackgroundFileSaver"
+);
+
+const StringInputStream = Components.Constructor(
+  "@mozilla.org/io/string-input-stream;1",
+  "nsIStringInputStream",
+  "setData"
+);
+
+const TEST_FILE_NAME_1 = "test-backgroundfilesaver-1.txt";
+
+const gAppRep = Cc[
+  "@mozilla.org/reputationservice/application-reputation-service;1"
+].getService(Ci.nsIApplicationReputationService);
+var gStillRunning = true;
+var gTables = {};
+var gHttpServer = null;
+
+const appRepURLPref = "browser.safebrowsing.downloads.remote.url";
+const remoteEnabledPref = "browser.safebrowsing.downloads.remote.enabled";
+
+function readFileToString(aFilename) {
+  let f = do_get_file(aFilename);
+  let stream = Cc["@mozilla.org/network/file-input-stream;1"].createInstance(
+    Ci.nsIFileInputStream
+  );
+  stream.init(f, -1, 0, 0);
+  let buf = NetUtil.readInputStreamToString(stream, stream.available());
+  return buf;
+}
+
+/**
+ * Waits for the given saver object to complete.
+ *
+ * @param aSaver
+ *        The saver, with the output stream or a stream listener implementation.
+ * @param aOnTargetChangeFn
+ *        Optional callback invoked with the target file name when it changes.
+ *
+ * @return {Promise}
+ * @resolves When onSaveComplete is called with a success code.
+ * @rejects With an exception, if onSaveComplete is called with a failure code.
+ */
+function promiseSaverComplete(aSaver, aOnTargetChangeFn) {
+  return new Promise((resolve, reject) => {
+    aSaver.observer = {
+      onTargetChange: function BFSO_onSaveComplete(unused, aTarget) {
+        if (aOnTargetChangeFn) {
+          aOnTargetChangeFn(aTarget);
+        }
+      },
+      onSaveComplete: function BFSO_onSaveComplete(unused, aStatus) {
+        if (Components.isSuccessCode(aStatus)) {
+          resolve();
+        } else {
+          reject(new Components.Exception("Saver failed.", aStatus));
+        }
+      },
+    };
+  });
+}
+
+/**
+ * Feeds a string to a BackgroundFileSaverOutputStream.
+ *
+ * @param aSourceString
+ *        The source data to copy.
+ * @param aSaverOutputStream
+ *        The BackgroundFileSaverOutputStream to feed.
+ * @param aCloseWhenDone
+ *        If true, the output stream will be closed when the copy finishes.
+ *
+ * @return {Promise}
+ * @resolves When the copy completes with a success code.
+ * @rejects With an exception, if the copy fails.
+ */
+function promiseCopyToSaver(aSourceString, aSaverOutputStream, aCloseWhenDone) {
+  return new Promise((resolve, reject) => {
+    let inputStream = new StringInputStream(
+      aSourceString,
+      aSourceString.length
+    );
+    let copier = Cc[
+      "@mozilla.org/network/async-stream-copier;1"
+    ].createInstance(Ci.nsIAsyncStreamCopier);
+    copier.init(
+      inputStream,
+      aSaverOutputStream,
+      null,
+      false,
+      true,
+      0x8000,
+      true,
+      aCloseWhenDone
+    );
+    copier.asyncCopy(
+      {
+        onStartRequest() {},
+        onStopRequest(aRequest, aContext, aStatusCode) {
+          if (Components.isSuccessCode(aStatusCode)) {
+            resolve();
+          } else {
+            reject(new Components.Exception(aStatusCode));
+          }
+        },
+      },
+      null
+    );
+  });
+}
+
+// Registers a table for which to serve update chunks.
+function registerTableUpdate(aTable, aFilename) {
+  // If we haven't been given an update for this table yet, add it to the map
+  if (!(aTable in gTables)) {
+    gTables[aTable] = [];
+  }
+
+  // The number of chunks associated with this table.
+  let numChunks = gTables[aTable].length + 1;
+  let redirectPath = "/" + aTable + "-" + numChunks;
+  let redirectUrl = "localhost:4444" + redirectPath;
+
+  // Store redirect url for that table so we can return it later when we
+  // process an update request.
+  gTables[aTable].push(redirectUrl);
+
+  gHttpServer.registerPathHandler(redirectPath, function (request, response) {
+    info("Mock safebrowsing server handling request for " + redirectPath);
+    let contents = readFileToString(aFilename);
+    info("Length of " + aFilename + ": " + contents.length);
+    response.setHeader(
+      "Content-Type",
+      "application/vnd.google.safebrowsing-update",
+      false
+    );
+    response.setStatusLine(request.httpVersion, 200, "OK");
+    response.bodyOutputStream.write(contents, contents.length);
+  });
+}
+
+// Tests
+
+add_task(async function test_setup() {
+  // Wait 10 minutes, that is half of the external xpcshell timeout.
+  do_timeout(10 * 60 * 1000, function () {
+    if (gStillRunning) {
+      do_throw("Test timed out.");
+    }
+  });
+  // Set up a local HTTP server to return bad verdicts.
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  // Ensure safebrowsing is enabled for this test, even if the app
+  // doesn't have it enabled.
+  Services.prefs.setBoolPref("browser.safebrowsing.malware.enabled", true);
+  Services.prefs.setBoolPref("browser.safebrowsing.downloads.enabled", true);
+  // Set block and allow tables explicitly, since the allowlist is normally
+  // disabled on comm-central.
+  Services.prefs.setCharPref(
+    "urlclassifier.downloadBlockTable",
+    "goog-badbinurl-shavar"
+  );
+  Services.prefs.setCharPref(
+    "urlclassifier.downloadAllowTable",
+    "goog-downloadwhite-digest256"
+  );
+  // SendRemoteQueryInternal needs locale preference.
+  let originalReqLocales = Services.locale.requestedLocales;
+  Services.locale.requestedLocales = ["en-US"];
+
+  registerCleanupFunction(function () {
+    Services.prefs.clearUserPref("browser.safebrowsing.malware.enabled");
+    Services.prefs.clearUserPref("browser.safebrowsing.downloads.enabled");
+    Services.prefs.clearUserPref("urlclassifier.downloadBlockTable");
+    Services.prefs.clearUserPref("urlclassifier.downloadAllowTable");
+    Services.locale.requestedLocales = originalReqLocales;
+  });
+
+  gHttpServer = new HttpServer();
+  gHttpServer.registerDirectory("/", do_get_cwd());
+
+  function createVerdict(aShouldBlock) {
+    // We can't programmatically create a protocol buffer here, so just
+    // hardcode some already serialized ones.
+    let blob = String.fromCharCode(parseInt(0x08, 16));
+    if (aShouldBlock) {
+      // A safe_browsing::ClientDownloadRequest with a DANGEROUS verdict
+      blob += String.fromCharCode(parseInt(0x01, 16));
+    } else {
+      // A safe_browsing::ClientDownloadRequest with a SAFE verdict
+      blob += String.fromCharCode(parseInt(0x00, 16));
+    }
+    return blob;
+  }
+
+  gHttpServer.registerPathHandler("/throw", function (request, response) {
+    do_throw("We shouldn't be getting here");
+  });
+
+  gHttpServer.registerPathHandler("/download", function (request, response) {
+    info("Querying remote server for verdict");
+    response.setHeader("Content-Type", "application/octet-stream", false);
+    let buf = NetUtil.readInputStreamToString(
+      request.bodyInputStream,
+      request.bodyInputStream.available()
+    );
+    info("Request length: " + buf.length);
+    // A garbage response. By default this produces NS_CANNOT_CONVERT_DATA as
+    // the callback status.
+    let blob =
+      "this is not a serialized protocol buffer (the length doesn't match our hard-coded values)";
+    // We can't actually parse the protocol buffer here, so just switch on the
+    // length instead of inspecting the contents.
+    if (buf.length == 67) {
+      // evil.com
+      blob = createVerdict(true);
+    } else if (buf.length == 73) {
+      // mozilla.com
+      blob = createVerdict(false);
+    }
+    response.bodyOutputStream.write(blob, blob.length);
+  });
+
+  gHttpServer.start(4444);
+
+  registerCleanupFunction(function () {
+    return (async function () {
+      await new Promise(resolve => {
+        gHttpServer.stop(resolve);
+      });
+    })();
+  });
+});
+
+// Construct a response with redirect urls.
+function processUpdateRequest() {
+  let response = "n:1000\n";
+  for (let table in gTables) {
+    response += "i:" + table + "\n";
+    for (let i = 0; i < gTables[table].length; ++i) {
+      response += "u:" + gTables[table][i] + "\n";
+    }
+  }
+  info("Returning update response: " + response);
+  return response;
+}
+
+// Set up the local whitelist.
+function waitForUpdates() {
+  return new Promise((resolve, reject) => {
+    gHttpServer.registerPathHandler("/downloads", function (request, response) {
+      let blob = processUpdateRequest();
+      response.setHeader(
+        "Content-Type",
+        "application/vnd.google.safebrowsing-update",
+        false
+      );
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.bodyOutputStream.write(blob, blob.length);
+    });
+
+    let streamUpdater = Cc[
+      "@mozilla.org/url-classifier/streamupdater;1"
+    ].getService(Ci.nsIUrlClassifierStreamUpdater);
+
+    // Load up some update chunks for the safebrowsing server to serve. This
+    // particular chunk contains the hash of whitelisted.com/ and
+    // sb-ssl.google.com/safebrowsing/csd/certificate/.
+    registerTableUpdate("goog-downloadwhite-digest256", "data/digest.chunk");
+
+    // Resolve the promise once processing the updates is complete.
+    function updateSuccess(aEvent) {
+      // Timeout of n:1000 is constructed in processUpdateRequest above and
+      // passed back in the callback in nsIUrlClassifierStreamUpdater on success.
+      Assert.equal("1000", aEvent);
+      info("All data processed");
+      resolve(true);
+    }
+    // Just throw if we ever get an update or download error.
+    function handleError(aEvent) {
+      do_throw("We didn't download or update correctly: " + aEvent);
+      reject();
+    }
+    streamUpdater.downloadUpdates(
+      "goog-downloadwhite-digest256",
+      "goog-downloadwhite-digest256;\n",
+      true,
+      "http://localhost:4444/downloads",
+      updateSuccess,
+      handleError,
+      handleError
+    );
+  });
+}
+
+function promiseQueryReputation(query, expected) {
+  return new Promise(resolve => {
+    function onComplete(aShouldBlock, aStatus) {
+      Assert.equal(Cr.NS_OK, aStatus);
+      check_telemetry(expected);
+      resolve(true);
+    }
+    gAppRep.queryReputation(query, onComplete);
+  });
+}
+
+add_task(async function () {
+  // Wait for Safebrowsing local list updates to complete.
+  await waitForUpdates();
+});
+
+add_task(async function test_signature_whitelists() {
+  // We should never get to the remote server.
+  Services.prefs.setBoolPref(remoteEnabledPref, true);
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/throw");
+
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, NonBinaryFile, 1);
+
+  // Use BackgroundFileSaver to extract the signature on Windows.
+  let destFile = FileTestUtils.getTempFile(TEST_FILE_NAME_1);
+
+  let data = readFileToString("data/signed_win.exe");
+  let saver = new BackgroundFileSaverOutputStream();
+  let completionPromise = promiseSaverComplete(saver);
+  saver.enableSignatureInfo();
+  saver.setTarget(destFile, false);
+  await promiseCopyToSaver(data, saver, true);
+
+  saver.finish(Cr.NS_OK);
+  await completionPromise;
+
+  // Clean up.
+  destFile.remove(false);
+
+  // evil.com is not on the allowlist, but this binary is signed by an entity
+  // whose certificate information is on the allowlist.
+  await promiseQueryReputation(
+    {
+      sourceURI: createURI("http://evil.com"),
+      signatureInfo: saver.signatureInfo,
+      fileSize: 12,
+    },
+    expected
+  );
+});
+
+add_task(async function test_blocked_binary() {
+  // We should reach the remote server for a verdict.
+  Services.prefs.setBoolPref(remoteEnabledPref, true);
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+
+  let expected = get_telemetry_snapshot();
+  expected.shouldBlock++;
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, VerdictDangerous, 1);
+
+  // evil.com should return a malware verdict from the remote server.
+  await promiseQueryReputation(
+    {
+      sourceURI: createURI("http://evil.com"),
+      suggestedFileName: "noop.bat",
+      fileSize: 12,
+      signatureInfo: [],
+    },
+    expected
+  );
+});
+
+add_task(async function test_non_binary() {
+  // We should not reach the remote server for a verdict for non-binary files.
+  Services.prefs.setBoolPref(remoteEnabledPref, true);
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/throw");
+
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, NonBinaryFile, 1);
+
+  await promiseQueryReputation(
+    {
+      sourceURI: createURI("http://evil.com"),
+      suggestedFileName: "noop.txt",
+      fileSize: 12,
+      signatureInfo: [],
+    },
+    expected
+  );
+});
+
+add_task(async function test_good_binary() {
+  // We should reach the remote server for a verdict.
+  Services.prefs.setBoolPref(remoteEnabledPref, true);
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, VerdictSafe, 1);
+
+  // mozilla.com should return a not-guilty verdict from the remote server.
+  await promiseQueryReputation(
+    {
+      sourceURI: createURI("http://mozilla.com"),
+      suggestedFileName: "noop.bat",
+      fileSize: 12,
+      signatureInfo: [],
+    },
+    expected
+  );
+});
+
+add_task(async function test_disabled() {
+  // Explicitly disable remote checks
+  Services.prefs.setBoolPref(remoteEnabledPref, false);
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/throw");
+
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, RemoteLookupDisabled, 1);
+
+  let query = {
+    sourceURI: createURI("http://example.com"),
+    suggestedFileName: "noop.bat",
+    signatureInfo: [],
+    fileSize: 12,
+  };
+  await new Promise(resolve => {
+    gAppRep.queryReputation(query, function onComplete(aShouldBlock, aStatus) {
+      // We should be getting NS_ERROR_NOT_AVAILABLE if the service is disabled
+      Assert.equal(Cr.NS_ERROR_NOT_AVAILABLE, aStatus);
+      Assert.ok(!aShouldBlock);
+      check_telemetry(expected);
+      resolve(true);
+    });
+  });
+});
+
+add_task(async function test_disabled_through_lists() {
+  Services.prefs.setBoolPref(remoteEnabledPref, false);
+  Services.prefs.setCharPref(appRepURLPref, "http://localhost:4444/download");
+  Services.prefs.setCharPref("urlclassifier.downloadBlockTable", "");
+
+  let expected = get_telemetry_snapshot();
+  add_telemetry_count(expected.local, NO_LIST, 1);
+  add_telemetry_count(expected.reason, RemoteLookupDisabled, 1);
+
+  let query = {
+    sourceURI: createURI("http://example.com"),
+    suggestedFileName: "noop.bat",
+    fileSize: 12,
+    signatureInfo: [],
+  };
+  await new Promise(resolve => {
+    gAppRep.queryReputation(query, function onComplete(aShouldBlock, aStatus) {
+      // We should be getting NS_ERROR_NOT_AVAILABLE if the service is disabled
+      Assert.equal(Cr.NS_ERROR_NOT_AVAILABLE, aStatus);
+      Assert.ok(!aShouldBlock);
+      check_telemetry(expected);
+      resolve(true);
+    });
+  });
+});
+add_task(async function test_teardown() {
+  gStillRunning = false;
+});
diff --git a/toolkit/components/reputationservice/test/unit/xpcshell.toml b/toolkit/components/reputationservice/test/unit/xpcshell.toml
new file mode 100644
index 0000000000..c3af8c7cae
--- /dev/null
+++ b/toolkit/components/reputationservice/test/unit/xpcshell.toml
@@ -0,0 +1,18 @@
+[DEFAULT]
+head = "head_download_manager.js"
+skip-if = ["os == 'android'"]
+support-files = [
+  "data/digest.chunk",
+  "data/block_digest.chunk",
+  "data/signed_win.exe",
+]
+
+["test_app_rep.js"]
+run-sequentially = "very high failure rate in parallel"
+
+["test_app_rep_maclinux.js"]
+skip-if = ["os == 'win'"]
+run-sequentially = "very high failure rate in parallel"
+
+["test_app_rep_windows.js"]
+run-if = ["os == 'win'"]