summaryrefslogtreecommitdiffstats
path: root/toolkit/components/reputationservice
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /toolkit/components/reputationservice
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'toolkit/components/reputationservice')
-rw-r--r--toolkit/components/reputationservice/ApplicationReputation.cpp1987
-rw-r--r--toolkit/components/reputationservice/ApplicationReputation.h60
-rw-r--r--toolkit/components/reputationservice/ApplicationReputationTelemetryUtils.cpp195
-rw-r--r--toolkit/components/reputationservice/ApplicationReputationTelemetryUtils.h45
-rw-r--r--toolkit/components/reputationservice/chromium/LICENSE27
-rw-r--r--toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.pb.cc26989
-rw-r--r--toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.pb.h32434
-rw-r--r--toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.proto1092
-rwxr-xr-xtoolkit/components/reputationservice/generate_csd.sh36
-rw-r--r--toolkit/components/reputationservice/moz.build40
-rw-r--r--toolkit/components/reputationservice/nsIApplicationReputation.idl147
-rw-r--r--toolkit/components/reputationservice/test/gtest/TestExecutableLists.cpp385
-rw-r--r--toolkit/components/reputationservice/test/gtest/moz.build16
-rw-r--r--toolkit/components/reputationservice/test/unit/data/block_digest.chunk2
-rw-r--r--toolkit/components/reputationservice/test/unit/data/digest.chunk3
-rw-r--r--toolkit/components/reputationservice/test/unit/data/signed_win.exebin0 -> 61064 bytes
-rw-r--r--toolkit/components/reputationservice/test/unit/head_download_manager.js134
-rw-r--r--toolkit/components/reputationservice/test/unit/test_app_rep.js571
-rw-r--r--toolkit/components/reputationservice/test/unit/test_app_rep_maclinux.js340
-rw-r--r--toolkit/components/reputationservice/test/unit/test_app_rep_windows.js484
-rw-r--r--toolkit/components/reputationservice/test/unit/xpcshell.toml18
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
Binary files differ
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'"]