diff options
Diffstat (limited to '')
27 files changed, 65885 insertions, 0 deletions
diff --git a/toolkit/components/reputationservice/ApplicationReputation.cpp b/toolkit/components/reputationservice/ApplicationReputation.cpp new file mode 100644 index 0000000000..a462a3a0ae --- /dev/null +++ b/toolkit/components/reputationservice/ApplicationReputation.cpp @@ -0,0 +1,1980 @@ +/* -*- 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", // MS ClickOnce + //".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 + ".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 + //".jnlp", exec // Java + //".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 + //".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", // 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..c248ead3a7 --- /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[187]; +#else + static const char* const kBinaryFileExtensions[186]; +#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..8a5aac6b1b --- /dev/null +++ b/toolkit/components/reputationservice/ApplicationReputationTelemetryUtils.cpp @@ -0,0 +1,194 @@ +/* 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" + +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/LoginReputation.cpp b/toolkit/components/reputationservice/LoginReputation.cpp new file mode 100644 index 0000000000..6e092b795e --- /dev/null +++ b/toolkit/components/reputationservice/LoginReputation.cpp @@ -0,0 +1,488 @@ +/* -*- Mode: C++; tab-width: 4; 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/. */ + +#include "LoginReputation.h" +#include "nsThreadUtils.h" +#include "mozilla/Components.h" +#include "mozilla/ErrorNames.h" +#include "mozilla/Logging.h" +#include "mozilla/net/UrlClassifierFeatureFactory.h" +#include "mozilla/Preferences.h" +#include "mozilla/ScopeExit.h" +#include "mozilla/StaticPrefs_browser.h" +#include "mozilla/Telemetry.h" +#include "mozilla/dom/ContentChild.h" +#include "mozilla/dom/HTMLInputElement.h" +#include "mozilla/ipc/URIUtils.h" +#include "nsIURIClassifier.h" +#include "nsIUrlClassifierFeature.h" + +using namespace mozilla; +using namespace mozilla::dom; + +#define PREF_PP_ENABLED "browser.safebrowsing.passwords.enabled" + +// MOZ_LOG=LoginReputation:5 +LazyLogModule gLoginReputationLogModule("LoginReputation"); +#define LR_LOG(args) \ + MOZ_LOG(gLoginReputationLogModule, mozilla::LogLevel::Debug, args) +#define LR_LOG_ENABLED() \ + MOZ_LOG_TEST(gLoginReputationLogModule, mozilla::LogLevel::Debug) + +static Atomic<bool> gShuttingDown(false); + +// ------------------------------------------------------------------------- +// ReputationQueryParam +// +// Concrete class for nsILoginReputationQuery to hold query parameters +// +class ReputationQueryParam final : public nsILoginReputationQuery { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSILOGINREPUTATIONQUERY + + explicit ReputationQueryParam(nsIURI* aURI) : mURI(aURI){}; + + private: + ~ReputationQueryParam() = default; + + nsCOMPtr<nsIURI> mURI; +}; + +NS_IMPL_ISUPPORTS(ReputationQueryParam, nsILoginReputationQuery) + +NS_IMETHODIMP +ReputationQueryParam::GetFormURI(nsIURI** aURI) { + NS_IF_ADDREF(*aURI = mURI); + return NS_OK; +} + +// ------------------------------------------------------------------------- +// LoginWhitelist +// +// This class is a wrapper that encapsulate asynchronous callback API provided +// by DBService into a MozPromise callback. +// +class LoginWhitelist final : public nsIUrlClassifierFeatureCallback { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIURLCLASSIFIERFEATURECALLBACK + + RefPtr<ReputationPromise> QueryLoginWhitelist( + nsILoginReputationQuery* aParam); + + LoginWhitelist() = default; + + nsresult Shutdown(); + + private: + ~LoginWhitelist() = default; + + // Queries that are waiting for callback from + // ::AsyncClassifyLocalWithFeatures. + nsTArray<UniquePtr<MozPromiseHolder<ReputationPromise>>> mQueryPromises; +}; + +NS_IMPL_ISUPPORTS(LoginWhitelist, nsIUrlClassifierFeatureCallback) + +nsresult LoginWhitelist::Shutdown() { + // Reject all query promise before releasing. + for (uint8_t i = 0; i < mQueryPromises.Length(); i++) { + mQueryPromises[i]->Reject(NS_ERROR_ABORT, __func__); + } + mQueryPromises.Clear(); + + return NS_OK; +} + +RefPtr<ReputationPromise> LoginWhitelist::QueryLoginWhitelist( + nsILoginReputationQuery* aParam) { + MOZ_ASSERT(NS_IsMainThread()); + + nsresult rv; + UniquePtr<MozPromiseHolder<ReputationPromise>> holder = + MakeUnique<MozPromiseHolder<ReputationPromise>>(); + RefPtr<ReputationPromise> p = holder->Ensure(__func__); + + // Return rejected promise while there is an error. + auto fail = MakeScopeExit([&]() { holder->Reject(rv, __func__); }); + + nsCOMPtr<nsIURI> uri; + rv = aParam->GetFormURI(getter_AddRefs(uri)); + if (NS_WARN_IF(NS_FAILED(rv) || !uri)) { + return p; + } + + nsCOMPtr<nsIURIClassifier> uriClassifier = + mozilla::components::UrlClassifierDB::Service(&rv); + if (NS_WARN_IF(NS_FAILED(rv))) { + return p; + } + + // AsyncClassifyLocalWithTables API won't trigger a gethash request on + // a full-length match, so this API call should only include local operation. + // We don't support prefs overwrite for this classification. + + nsCOMPtr<nsIUrlClassifierFeature> feature = + mozilla::net::UrlClassifierFeatureFactory::GetFeatureLoginReputation(); + if (NS_WARN_IF(!feature)) { + return p; + } + + nsTArray<RefPtr<nsIUrlClassifierFeature>> features; + features.AppendElement(feature); + + rv = uriClassifier->AsyncClassifyLocalWithFeatures( + uri, features, nsIUrlClassifierFeature::entitylist, this); + if (NS_FAILED(rv)) { + return p; + } + + fail.release(); + mQueryPromises.AppendElement(std::move(holder)); + return p; +} + +nsresult LoginWhitelist::OnClassifyComplete( + const nsTArray<RefPtr<nsIUrlClassifierFeatureResult>>& aResults) { + MOZ_ASSERT(NS_IsMainThread()); + + if (gShuttingDown) { + return NS_OK; + } + + LR_LOG(("OnClassifyComplete : %s", + aResults.IsEmpty() ? "blacklisted" : "whitelisted")); + + UniquePtr<MozPromiseHolder<ReputationPromise>> holder = + std::move(mQueryPromises.ElementAt(0)); + mQueryPromises.RemoveElementAt(0); + + if (aResults.IsEmpty()) { + // Reject if we can not find url in white list. + holder->Reject(NS_OK, __func__); + } else { + holder->Resolve(nsILoginReputationVerdictType::SAFE, __func__); + } + + return NS_OK; +} + +// ------------------------------------------------------------------------- +// LoginReputationService +// +NS_IMPL_ISUPPORTS(LoginReputationService, nsILoginReputationService, + nsIObserver) + +LoginReputationService* LoginReputationService::gLoginReputationService = + nullptr; + +// static +already_AddRefed<LoginReputationService> +LoginReputationService::GetSingleton() { + if (!gLoginReputationService) { + gLoginReputationService = new LoginReputationService(); + } + return do_AddRef(gLoginReputationService); +} + +LoginReputationService::LoginReputationService() { + LR_LOG(("Login reputation service starting up")); +} + +LoginReputationService::~LoginReputationService() { + LR_LOG(("Login reputation service shutting down")); + + MOZ_ASSERT(gLoginReputationService == this); + + gLoginReputationService = nullptr; +} + +NS_IMETHODIMP +LoginReputationService::Init() { + MOZ_ASSERT(NS_IsMainThread()); + + switch (XRE_GetProcessType()) { + case GeckoProcessType_Default: + LR_LOG(("Init login reputation service in parent")); + break; + case GeckoProcessType_Content: + LR_LOG(("Init login reputation service in child")); + // Login reputation service in child process will only forward request to + // parent, return here to skip unnecessary initialization. + return NS_OK; + default: + // No other process type is supported! + return NS_ERROR_NOT_AVAILABLE; + } + + // The initialization below only happens in parent process. + Preferences::AddStrongObserver(this, PREF_PP_ENABLED); + + // Init should only be called once. + MOZ_ASSERT(!mLoginWhitelist); + + mLoginWhitelist = new LoginWhitelist(); + + if (StaticPrefs::browser_safebrowsing_passwords_enabled()) { + Enable(); + } + + return NS_OK; +} + +nsresult LoginReputationService::Enable() { + MOZ_ASSERT(XRE_IsParentProcess()); + MOZ_ASSERT(StaticPrefs::browser_safebrowsing_passwords_enabled()); + + LR_LOG(("Enable login reputation service")); + + return NS_OK; +} + +nsresult LoginReputationService::Disable() { + MOZ_ASSERT(XRE_IsParentProcess()); + + LR_LOG(("Disable login reputation service")); + + nsresult rv = mLoginWhitelist->Shutdown(); + Unused << NS_WARN_IF(NS_FAILED(rv)); + + mQueryRequests.Clear(); + + return NS_OK; +} + +nsresult LoginReputationService::Shutdown() { + MOZ_ASSERT(XRE_IsParentProcess()); + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(gShuttingDown); + + // Disable will wait until worker threads are shutdown. + Disable(); + + // Disable will only destroy worker thread, it won't null out these classes. + // So we will null these classes in shutdown. + mLoginWhitelist = nullptr; + + return NS_OK; +} + +// static +already_AddRefed<nsILoginReputationQuery> +LoginReputationService::ConstructQueryParam(nsIURI* aURI) { + RefPtr<ReputationQueryParam> param = new ReputationQueryParam(aURI); + return param.forget(); +} + +NS_IMETHODIMP +LoginReputationService::QueryReputationAsync( + HTMLInputElement* aInput, nsILoginReputationQueryCallback* aCallback) { + NS_ENSURE_ARG_POINTER(aInput); + + LR_LOG(("QueryReputationAsync() [this=%p]", this)); + + if (!StaticPrefs::browser_safebrowsing_passwords_enabled()) { + return NS_ERROR_FAILURE; + } + + nsIURI* documentURI = aInput->OwnerDoc()->GetDocumentURI(); + NS_ENSURE_STATE(documentURI); + + if (XRE_IsContentProcess()) { + using namespace mozilla::ipc; + + ContentChild* content = ContentChild::GetSingleton(); + if (content->IsShuttingDown()) { + return NS_ERROR_FAILURE; + } + + if (!content->SendPLoginReputationConstructor(documentURI)) { + return NS_ERROR_FAILURE; + } + } else { + nsCOMPtr<nsILoginReputationQuery> query = + LoginReputationService::ConstructQueryParam(documentURI); + + nsresult rv = QueryReputation(query, aCallback); + return rv; + } + + return NS_OK; +} + +NS_IMETHODIMP +LoginReputationService::QueryReputation( + nsILoginReputationQuery* aQuery, + nsILoginReputationQueryCallback* aCallback) { + MOZ_ASSERT(NS_IsMainThread()); + + NS_ENSURE_ARG_POINTER(aQuery); + NS_ENSURE_ARG_POINTER(aCallback); + + LR_LOG(("QueryReputation() [this=%p]", this)); + + if (gShuttingDown || !StaticPrefs::browser_safebrowsing_passwords_enabled()) { + LR_LOG(("QueryReputation() abort [this=%p]", this)); + aCallback->OnComplete(NS_ERROR_ABORT, + nsILoginReputationVerdictType::UNSPECIFIED); + return NS_OK; + } + + // mQueryRequests is an array used to maintain the ownership of + // |QueryRequest|. We ensure that |QueryRequest| is always valid until + // Finish() is called or LoginReputationService is shutdown. + auto request = + mQueryRequests.AppendElement(MakeUnique<QueryRequest>(aQuery, aCallback)); + + return QueryLoginWhitelist(request->get()); +} + +nsresult LoginReputationService::QueryLoginWhitelist(QueryRequest* aRequest) { + MOZ_ASSERT(NS_IsMainThread()); + + NS_ENSURE_ARG_POINTER(aRequest); + + if (gShuttingDown) { + return NS_ERROR_ABORT; + } + + using namespace mozilla::Telemetry; + TimeStamp startTimeMs = TimeStamp::Now(); + + RefPtr<LoginReputationService> self = this; + + mLoginWhitelist->QueryLoginWhitelist(aRequest->mParam) + ->Then( + GetCurrentSerialEventTarget(), __func__, + [self, aRequest, startTimeMs](VerdictType aResolveValue) -> void { + // Promise is resolved if url is found in google-provided whitelist. + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aResolveValue == nsILoginReputationVerdictType::SAFE); + + LR_LOG(("Query login whitelist [request = %p, result = SAFE]", + aRequest)); + + AccumulateTimeDelta(LOGIN_REPUTATION_LOGIN_WHITELIST_LOOKUP_TIME, + startTimeMs); + + Accumulate(LOGIN_REPUTATION_LOGIN_WHITELIST_RESULT, + nsILoginReputationVerdictType::SAFE); + + self->Finish(aRequest, NS_OK, nsILoginReputationVerdictType::SAFE); + }, + [self, aRequest, startTimeMs](nsresult rv) -> void { + // Promise is rejected if url cannot be found in google-provided + // whitelist. or there is an error. + if (NS_FAILED(rv)) { + if (LR_LOG_ENABLED()) { + nsAutoCString errorName; + mozilla::GetErrorName(rv, errorName); + LR_LOG( + ("Error in QueryLoginWhitelist() [request = %p, rv = %s]", + aRequest, errorName.get())); + } + + // Don't record the lookup time when there is an error, only + // record the result here. + Accumulate(LOGIN_REPUTATION_LOGIN_WHITELIST_RESULT, + 2); // 2 is error + } else { + AccumulateTimeDelta(LOGIN_REPUTATION_LOGIN_WHITELIST_LOOKUP_TIME, + startTimeMs); + + Accumulate(LOGIN_REPUTATION_LOGIN_WHITELIST_RESULT, + nsILoginReputationVerdictType::UNSPECIFIED); + + LR_LOG( + ("Query login whitelist cannot find the URL [request = %p]", + aRequest)); + } + + // Check trust-based whitelisting if we can't find the url in login + // whitelist + self->Finish(aRequest, rv, + nsILoginReputationVerdictType::UNSPECIFIED); + }); + + return NS_OK; +} + +nsresult LoginReputationService::Finish(const QueryRequest* aRequest, + nsresult aStatus, + VerdictType aVerdict) { + MOZ_ASSERT(NS_IsMainThread()); + + NS_ENSURE_ARG_POINTER(aRequest); + + LR_LOG(("Query login reputation end [request = %p, result = %s]", aRequest, + VerdictTypeToString(aVerdict).get())); + + // Since we are shutting down, don't bother call back to child process. + if (gShuttingDown) { + return NS_OK; + } + + aRequest->mCallback->OnComplete(aStatus, aVerdict); + + // QueryRequest may not follow the same order when we queued it in + // ::QueryReputation because one query request may be finished earlier than + // the other. + uint32_t idx = 0; + for (; idx < mQueryRequests.Length(); idx++) { + if (mQueryRequests[idx].get() == aRequest) { + break; + } + } + + if (NS_WARN_IF(idx >= mQueryRequests.Length())) { + return NS_ERROR_FAILURE; + } + mQueryRequests.RemoveElementAt(idx); + + return NS_OK; +} + +NS_IMETHODIMP +LoginReputationService::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) { + nsDependentString data(aData); + + if (data.EqualsLiteral(PREF_PP_ENABLED)) { + nsresult rv = StaticPrefs::browser_safebrowsing_passwords_enabled() + ? Enable() + : Disable(); + Unused << NS_WARN_IF(NS_FAILED(rv)); + } + } else if (!strcmp(aTopic, "quit-application")) { + // Prepare to shutdown, won't allow any query request after 'gShuttingDown' + // is set. + gShuttingDown = true; + } else if (!strcmp(aTopic, "profile-before-change")) { + gShuttingDown = true; + Shutdown(); + } else { + return NS_ERROR_UNEXPECTED; + } + + return NS_OK; +} + +// static +nsCString LoginReputationService::VerdictTypeToString(VerdictType aVerdict) { + switch (aVerdict) { + case nsILoginReputationVerdictType::UNSPECIFIED: + return nsCString("Unspecified"); + case nsILoginReputationVerdictType::LOW_REPUTATION: + return nsCString("Low Reputation"); + case nsILoginReputationVerdictType::SAFE: + return nsCString("Safe"); + case nsILoginReputationVerdictType::PHISHING: + return nsCString("Phishing"); + default: + return nsCString("Invalid"); + } +} diff --git a/toolkit/components/reputationservice/LoginReputation.h b/toolkit/components/reputationservice/LoginReputation.h new file mode 100644 index 0000000000..a95a9d1d8a --- /dev/null +++ b/toolkit/components/reputationservice/LoginReputation.h @@ -0,0 +1,77 @@ +/* -*- Mode: C++; tab-width: 4; 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 LoginReputation_h__ +#define LoginReputation_h__ + +#include "mozilla/Logging.h" +#include "mozilla/MozPromise.h" +#include "nsILoginReputation.h" +#include "nsIObserver.h" +#include "nsISupportsImpl.h" + +class LoginWhitelist; + +namespace mozilla { + +typedef uint32_t VerdictType; +typedef MozPromise<VerdictType, nsresult, false> ReputationPromise; + +class LoginReputationService final : public nsILoginReputationService, + public nsIObserver { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSILOGINREPUTATIONSERVICE + NS_DECL_NSIOBSERVER + + public: + static already_AddRefed<LoginReputationService> GetSingleton(); + + static already_AddRefed<nsILoginReputationQuery> ConstructQueryParam( + nsIURI* aURI); + + static nsCString VerdictTypeToString(VerdictType aVerdict); + + private: + struct QueryRequest { + QueryRequest(nsILoginReputationQuery* aParam, + nsILoginReputationQueryCallback* aCallback) + : mParam(aParam), mCallback(aCallback) {} + + nsCOMPtr<nsILoginReputationQuery> mParam; + nsCOMPtr<nsILoginReputationQueryCallback> mCallback; + }; + + /** + * Global singleton object for holding this factory service. + */ + static LoginReputationService* gLoginReputationService; + + LoginReputationService(); + ~LoginReputationService(); + + nsresult Enable(); + + nsresult Disable(); + + nsresult QueryLoginWhitelist(QueryRequest* aRequest); + + // Called when a query request is finished. + nsresult Finish(const QueryRequest* aRequest, nsresult aStatus, + VerdictType aVerdict); + + // Clear data and join the worker threads. + nsresult Shutdown(); + + RefPtr<LoginWhitelist> mLoginWhitelist; + + // Array that holds ongoing query requests which are added when + // ::QueryReputation is called. + nsTArray<UniquePtr<QueryRequest>> mQueryRequests; +}; + +} // namespace mozilla + +#endif // LoginReputation_h__ diff --git a/toolkit/components/reputationservice/LoginReputationIPC.cpp b/toolkit/components/reputationservice/LoginReputationIPC.cpp new file mode 100644 index 0000000000..3bac199219 --- /dev/null +++ b/toolkit/components/reputationservice/LoginReputationIPC.cpp @@ -0,0 +1,56 @@ + +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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 "LoginReputationIPC.h" +#include "mozilla/Components.h" +#include "mozilla/Unused.h" + +using namespace mozilla; +using namespace mozilla::dom; + +// MOZ_LOG=LoginReputation:5 +extern LazyLogModule gLoginReputationLogModule; +#define LR_LOG(args) \ + MOZ_LOG(gLoginReputationLogModule, mozilla::LogLevel::Debug, args) +#define LR_LOG_ENABLED() \ + MOZ_LOG_TEST(gLoginReputationLogModule, mozilla::LogLevel::Debug) + +NS_IMPL_ISUPPORTS(LoginReputationParent, nsILoginReputationQueryCallback) + +mozilla::ipc::IPCResult LoginReputationParent::QueryReputation(nsIURI* aURI) { + nsresult rv; + nsCOMPtr<nsILoginReputationService> service = + components::LoginReputation::Service(&rv); + if (NS_FAILED(rv)) { + Unused << Send__delete__(this); + return IPC_OK(); + } + + nsCOMPtr<nsILoginReputationQuery> query = + LoginReputationService::ConstructQueryParam(aURI); + rv = service->QueryReputation(query, this); + if (NS_FAILED(rv)) { + Unused << Send__delete__(this); + } + + return IPC_OK(); +} + +NS_IMETHODIMP +LoginReputationParent::OnComplete(nsresult aResult, VerdictType aVerdict) { + LR_LOG(("OnComplete() [verdict=%s]", + LoginReputationService::VerdictTypeToString(aVerdict).get())); + + if (mIPCOpen) { + Unused << Send__delete__(this); + } + return NS_OK; +} + +void LoginReputationParent::ActorDestroy(ActorDestroyReason aWhy) { + mIPCOpen = false; +} diff --git a/toolkit/components/reputationservice/LoginReputationIPC.h b/toolkit/components/reputationservice/LoginReputationIPC.h new file mode 100644 index 0000000000..ad0148271a --- /dev/null +++ b/toolkit/components/reputationservice/LoginReputationIPC.h @@ -0,0 +1,36 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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 mozilla_dom_LoginReputationIPC_h +#define mozilla_dom_LoginReputationIPC_h + +#include "mozilla/dom/PLoginReputationParent.h" +#include "nsILoginReputation.h" + +namespace mozilla { +namespace dom { + +class LoginReputationParent : public nsILoginReputationQueryCallback, + public PLoginReputationParent { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSILOGINREPUTATIONQUERYCALLBACK + + LoginReputationParent() = default; + + mozilla::ipc::IPCResult QueryReputation(nsIURI* aURI); + + void ActorDestroy(ActorDestroyReason aWhy) override; + + private: + ~LoginReputationParent() = default; + bool mIPCOpen = true; +}; + +} // namespace dom +} // namespace mozilla + +#endif // mozilla_dom_LoginReputationIPC_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..b557724a02 --- /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/+/master/components/safe_browsing/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..3aeefc9583 --- /dev/null +++ b/toolkit/components/reputationservice/moz.build @@ -0,0 +1,45 @@ +# -*- 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.ini"] + +EXPORTS.mozilla += ["ApplicationReputation.h", "LoginReputationIPC.h"] + +XPIDL_SOURCES += [ + "nsIApplicationReputation.idl", + "nsILoginReputation.idl", +] + +XPIDL_MODULE = "reputationservice" + +UNIFIED_SOURCES += [ + "ApplicationReputation.cpp", + "ApplicationReputationTelemetryUtils.cpp", + "chromium/chrome/common/safe_browsing/csd.pb.cc", + "LoginReputation.cpp", + "LoginReputationIPC.cpp", +] + +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"] + +REQUIRES_UNIFIED_BUILD = True 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/nsILoginReputation.idl b/toolkit/components/reputationservice/nsILoginReputation.idl new file mode 100644 index 0000000000..05c53988a6 --- /dev/null +++ b/toolkit/components/reputationservice/nsILoginReputation.idl @@ -0,0 +1,47 @@ +/* -*- 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 nsIURI; + +webidl HTMLInputElement; + +[scriptable, uuid(6219f9da-297e-446d-8d47-ccdd8e72a1d5)] +interface nsILoginReputationVerdictType : nsISupports { + + const unsigned long UNSPECIFIED = 0; + const unsigned long SAFE = 1; + const unsigned long LOW_REPUTATION = 2; + const unsigned long PHISHING = 3; +}; + +[scriptable, uuid(c21ffe59-595f-46c8-9052-fefb639e196e)] +interface nsILoginReputationQuery : nsISupports { + readonly attribute nsIURI formURI; +}; + +[scriptable, uuid(b527be1e-8fbb-41d9-bee4-267a71236368)] +interface nsILoginReputationQueryCallback : nsISupports { + // aVerdict should be one of the const value defined in nsILoginReputationResult + // interface. + void onComplete(in nsresult aStatus, + in unsigned long aVerdict); +}; + +[scriptable, uuid(1b3f1dfe-ce3a-486b-953e-ce5ac863eff9)] +interface nsILoginReputationService : nsISupports { + void init(); + + // If QueryReputationAsync is called from child, it will make a IPC call + // to parent. + void queryReputationAsync(in HTMLInputElement aInput, + in nsILoginReputationQueryCallback aCallback); + + // QueryReputation can only be called from parent + void queryReputation(in nsILoginReputationQuery aQuery, + in nsILoginReputationQueryCallback aCallback); +}; diff --git a/toolkit/components/reputationservice/test/gtest/TestExecutableLists.cpp b/toolkit/components/reputationservice/test/gtest/TestExecutableLists.cpp new file mode 100644 index 0000000000..3c24221b87 --- /dev/null +++ b/toolkit/components/reputationservice/test/gtest/TestExecutableLists.cpp @@ -0,0 +1,376 @@ +/* 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" + +// 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 + ".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 + ".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 + ".jnlp", // Java + ".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 + ".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 +}; + +#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..384076b57f --- /dev/null +++ b/toolkit/components/reputationservice/test/gtest/moz.build @@ -0,0 +1,18 @@ +# -*- 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" + +REQUIRES_UNIFIED_BUILD = True 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 Binary files differnew file mode 100644 index 0000000000..de3bb40e84 --- /dev/null +++ b/toolkit/components/reputationservice/test/unit/data/signed_win.exe diff --git a/toolkit/components/reputationservice/test/unit/head_download_manager.js b/toolkit/components/reputationservice/test/unit/head_download_manager.js new file mode 100644 index 0000000000..292ff96f9e --- /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.import("resource://testing-common/httpd.js"); + +// 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..854c8ad11c --- /dev/null +++ b/toolkit/components/reputationservice/test/unit/test_app_rep.js @@ -0,0 +1,569 @@ +/* -*- 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.import("resource://gre/modules/NetUtil.jsm"); + +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..0c5eadaf1d --- /dev/null +++ b/toolkit/components/reputationservice/test/unit/test_app_rep_maclinux.js @@ -0,0 +1,342 @@ +/* -*- 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.defineModuleGetter( + this, + "NetUtil", + "resource://gre/modules/NetUtil.jsm" +); + +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..2de0949262 --- /dev/null +++ b/toolkit/components/reputationservice/test/unit/test_app_rep_windows.js @@ -0,0 +1,488 @@ +/* -*- 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.defineModuleGetter( + this, + "NetUtil", + "resource://gre/modules/NetUtil.jsm" +); +ChromeUtils.defineESModuleGetters(this, { + FileTestUtils: "resource://testing-common/FileTestUtils.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/test_login_rep.js b/toolkit/components/reputationservice/test/unit/test_login_rep.js new file mode 100644 index 0000000000..d81815996f --- /dev/null +++ b/toolkit/components/reputationservice/test/unit/test_login_rep.js @@ -0,0 +1,183 @@ +/* -*- 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.import("resource://gre/modules/NetUtil.jsm"); + +// LoginReputationService +const gLoginRep = Cc[ + "@mozilla.org/reputationservice/login-reputation-service;1" +].getService(Ci.nsILoginReputationService); + +let gListManager = Cc["@mozilla.org/url-classifier/listmanager;1"].getService( + Ci.nsIUrlListManager +); + +var gHttpServ = null; + +const whitelistedURI = "http://foo:bar@whitelisted.com/index.htm#junk"; +const exampleURI = "http://user:password@example.com/i.html?foo=bar"; + +const LOCAL_WHITELIST_DATA = { + tableName: "test-passwordwhite-proto", + providerName: "test", + updateUrl: "http://localhost:5555/safebrowsing/update?", + gethashUrl: "", +}; + +add_task(async function test_setup() { + // Enable login reputation service + Services.prefs.setBoolPref("browser.safebrowsing.passwords.enabled", true); + gLoginRep.init(); + + // Setup local whitelist table. + Services.prefs.setCharPref( + "urlclassifier.passwordAllowTable", + "test-passwordwhite-proto" + ); + gListManager.registerTable( + LOCAL_WHITELIST_DATA.tableName, + LOCAL_WHITELIST_DATA.providerName, + LOCAL_WHITELIST_DATA.updateUrl, + LOCAL_WHITELIST_DATA.gethashUrl + ); + + registerCleanupFunction(function() { + gListManager.unregisterTable(LOCAL_WHITELIST_DATA.tableName); + + Services.prefs.clearUserPref("browser.safebrowsing.passwords.enabled"); + Services.prefs.clearUserPref("urlclassifier.passwordAllowTable"); + }); +}); + +add_test(function test_setup_local_whitelist() { + // Setup the http server for SafeBrowsing update, so we can save SAFE entries + // to SafeBrowsing database while update. + gHttpServ = new HttpServer(); + gHttpServ.registerDirectory("/", do_get_cwd()); + gHttpServ.registerPathHandler("/safebrowsing/update", function( + request, + response + ) { + response.setHeader( + "Content-Type", + "application/vnd.google.safebrowsing-update", + false + ); + + response.setStatusLine(request.httpVersion, 200, "OK"); + + // The protobuf binary represention of response: + // + // [ + // { + // 'threat_type': 8, // CSD_WHITELIST + // 'response_type': 2, // FULL_UPDATE + // 'new_client_state': 'sta\x00te', // NEW_CLIENT_STATE + // 'checksum': { "sha256": CHECKSUM }, // CHECKSUM + // 'additions': { 'compression_type': RAW, + // 'prefix_size': 32, + // 'raw_hashes': "whitelisted.com/index.htm"} + // } + // ] + // + let content = + "\x0A\x36\x08\x08\x20\x02\x2A\x28\x08\x01\x12\x24\x08" + + "\x20\x12\x20\x0F\xE4\x66\xBB\xDD\x34\xAB\x1E\xF7\x8F" + + "\xDD\x9D\x8C\xF8\x9F\x4E\x42\x97\x92\x86\x02\x03\xE0" + + "\xE9\x60\xBD\xD6\x3A\x85\xCD\x08\xD0\x3A\x06\x73\x74" + + "\x61\x00\x74\x65\x12\x04\x08\x0C\x10\x0A"; + + response.bodyOutputStream.write(content, content.length); + }); + + gHttpServ.start(5555); + + // Trigger the update once http server is ready. + Services.obs.addObserver(function(aSubject, aTopic, aData) { + if (aData.startsWith("success")) { + run_next_test(); + } else { + do_throw("update fail"); + } + }, "safebrowsing-update-finished"); + gListManager.forceUpdates(LOCAL_WHITELIST_DATA.tableName); + + registerCleanupFunction(function() { + return (async function() { + await new Promise(resolve => { + gHttpServ.stop(resolve); + }); + })(); + }); +}); + +add_test(function test_disable() { + Services.prefs.setBoolPref("browser.safebrowsing.passwords.enabled", false); + + gLoginRep.queryReputation( + { + formURI: NetUtil.newURI("http://example.com"), + }, + { + onComplete(aStatus, aVerdict) { + Assert.equal(aStatus, Cr.NS_ERROR_ABORT); + Assert.equal(aVerdict, Ci.nsILoginReputationVerdictType.UNSPECIFIED); + + Services.prefs.setBoolPref( + "browser.safebrowsing.passwords.enabled", + true + ); + + run_next_test(); + }, + } + ); +}); + +add_test(function test_nullQuery() { + try { + gLoginRep.queryReputation(null, { + onComplete(aStatus, aVerdict) {}, + }); + do_throw("Query parameter cannot be null"); + } catch (ex) { + Assert.equal(ex.result, Cr.NS_ERROR_INVALID_POINTER); + + run_next_test(); + } +}); + +add_test(function test_local_whitelist() { + gLoginRep.queryReputation( + { + formURI: NetUtil.newURI(whitelistedURI), + }, + { + onComplete(aStatus, aVerdict) { + Assert.equal(aStatus, Cr.NS_OK); + Assert.equal(aVerdict, Ci.nsILoginReputationVerdictType.SAFE); + + run_next_test(); + }, + } + ); +}); + +add_test(function test_notin_local_whitelist() { + gLoginRep.queryReputation( + { + formURI: NetUtil.newURI(exampleURI), + }, + { + onComplete(aStatus, aVerdict) { + Assert.equal(aStatus, Cr.NS_OK); + Assert.equal(aVerdict, Ci.nsILoginReputationVerdictType.UNSPECIFIED); + + run_next_test(); + }, + } + ); +}); diff --git a/toolkit/components/reputationservice/test/unit/xpcshell.ini b/toolkit/components/reputationservice/test/unit/xpcshell.ini new file mode 100644 index 0000000000..eb1f1ebbed --- /dev/null +++ b/toolkit/components/reputationservice/test/unit/xpcshell.ini @@ -0,0 +1,17 @@ +[DEFAULT] +head = head_download_manager.js +skip-if = toolkit == '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_windows.js] +skip-if = os != "win" +[test_app_rep_maclinux.js] +skip-if = os == "win" +run-sequentially = very high failure rate in parallel + +[test_login_rep.js] |