diff options
Diffstat (limited to '')
27 files changed, 61537 insertions, 0 deletions
diff --git a/toolkit/components/reputationservice/ApplicationReputation.cpp b/toolkit/components/reputationservice/ApplicationReputation.cpp new file mode 100644 index 0000000000..1f73e29e64 --- /dev/null +++ b/toolkit/components/reputationservice/ApplicationReputation.cpp @@ -0,0 +1,1996 @@ +/* -*- 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[] = { + ".ad", + ".air", +}; + +// 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 + ".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 nsIObserver, + public nsSupportsWeakReference { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + NS_DECL_NSITIMERCALLBACK + 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, nsISupports* aContext, + 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) + +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) { + nsresult rv; + + nsCOMPtr<nsICryptoHash> cryptoHash = + do_CreateInstance("@mozilla.org/security/hash;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + rv = cryptoHash->Init(nsICryptoHash::SHA256); + 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; + + } else 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)); + } + + // Look for truncated hashes (see bug 1190020) + const auto originalHashLength = sha256Hash.Length(); + if (originalHashLength == 0) { + AccumulateCategorical( + mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_HASH_LENGTH:: + OriginalHashEmpty); + } else if (originalHashLength < 32) { + AccumulateCategorical( + mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_HASH_LENGTH:: + OriginalHashTooShort); + } else if (originalHashLength > 32) { + AccumulateCategorical( + mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_HASH_LENGTH:: + OriginalHashTooLong); + } else if (!mRequest.has_digests()) { + AccumulateCategorical( + mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_HASH_LENGTH:: + MissingDigest); + } else if (!mRequest.digests().has_sha256()) { + AccumulateCategorical( + mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_HASH_LENGTH:: + MissingSha256); + } else if (mRequest.digests().sha256().size() != originalHashLength) { + AccumulateCategorical( + mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_HASH_LENGTH:: + InvalidSha256); + } else { + AccumulateCategorical( + mozilla::Telemetry::LABELS_APPLICATION_REPUTATION_HASH_LENGTH:: + ValidHash); + } + + // 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=%d) %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); + mTimeoutTimer->Cancel(); + 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) { + 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, nullptr, aResult, verdict, reason); + OnComplete(verdict, reason, rv); + return rv; +} + +nsresult PendingLookup::OnStopRequestInternal(nsIRequest* aRequest, + nsISupports* aContext, + 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)); + NS_ENSURE_STATE(lookup); + + // 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; +} diff --git a/toolkit/components/reputationservice/ApplicationReputation.h b/toolkit/components/reputationservice/ApplicationReputation.h new file mode 100644 index 0000000000..c0011f0620 --- /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[2]; +#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..c5484ca07b --- /dev/null +++ b/toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.pb.cc @@ -0,0 +1,24714 @@ +// 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> +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ChromeUserPopulation_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadReport_UserInformation_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<7> scc_info_ClientDownloadRequest_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ClientDownloadRequest_ArchivedBinary_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientDownloadRequest_CertificateChain_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadRequest_CertificateChain_Element_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadRequest_Digests_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadRequest_ExtendedAttr_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientDownloadRequest_ImageHeaders_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientDownloadRequest_MachOHeaders_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadRequest_MachOHeaders_LoadCommand_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientDownloadRequest_PEImageHeaders_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadRequest_PEImageHeaders_DebugData_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadRequest_Resource_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientDownloadRequest_SignatureInfo_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientDownloadResponse_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadResponse_MoreInfo_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientIncidentReport_DownloadDetails_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ClientIncidentReport_EnvironmentData_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_EnvironmentData_Machine_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientIncidentReport_EnvironmentData_OS_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientIncidentReport_EnvironmentData_OS_RegistryKey_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_EnvironmentData_OS_RegistryValue_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_ClientIncidentReport_EnvironmentData_Process_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientIncidentReport_EnvironmentData_Process_Dll_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_EnvironmentData_Process_NetworkProvider_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_EnvironmentData_Process_Patch_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientIncidentReport_ExtensionData_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_ExtensionData_ExtensionInfo_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ClientIncidentReport_IncidentData_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_IncidentData_ResourceRequestIncident_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_IncidentData_TrackedPreferenceIncident_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_NonBinaryDownloadDetails_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentResponse_EnvironmentRequest_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientMalwareRequest_UrlInfo_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientPhishingRequest_Feature_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientSafeBrowsingReportRequest_HTTPHeader_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientSafeBrowsingReportRequest_HTTPRequest_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientSafeBrowsingReportRequest_HTTPResponse_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientSafeBrowsingReportRequest_Resource_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_HTMLElement_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HTMLElement_Attribute_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ImageData_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ImageData_Dimensions_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_LoginReputationClientRequest_Frame_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LoginReputationClientRequest_Frame_Form_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LoginReputationClientRequest_PasswordReuseEvent_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ReferrerChainEntry_csd_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_csd_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ReferrerChainEntry_ServerRedirect_csd_2eproto; +namespace safe_browsing { +class ChromeUserPopulationDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ChromeUserPopulation> _instance; +} _ChromeUserPopulation_default_instance_; +class ClientPhishingRequest_FeatureDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientPhishingRequest_Feature> _instance; +} _ClientPhishingRequest_Feature_default_instance_; +class ClientPhishingRequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientPhishingRequest> _instance; +} _ClientPhishingRequest_default_instance_; +class ClientPhishingResponseDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientPhishingResponse> _instance; +} _ClientPhishingResponse_default_instance_; +class ClientMalwareRequest_UrlInfoDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientMalwareRequest_UrlInfo> _instance; +} _ClientMalwareRequest_UrlInfo_default_instance_; +class ClientMalwareRequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientMalwareRequest> _instance; +} _ClientMalwareRequest_default_instance_; +class LoginReputationClientRequest_Frame_FormDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<LoginReputationClientRequest_Frame_Form> _instance; +} _LoginReputationClientRequest_Frame_Form_default_instance_; +class LoginReputationClientRequest_FrameDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<LoginReputationClientRequest_Frame> _instance; +} _LoginReputationClientRequest_Frame_default_instance_; +class LoginReputationClientRequest_PasswordReuseEventDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<LoginReputationClientRequest_PasswordReuseEvent> _instance; +} _LoginReputationClientRequest_PasswordReuseEvent_default_instance_; +class LoginReputationClientRequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<LoginReputationClientRequest> _instance; +} _LoginReputationClientRequest_default_instance_; +class LoginReputationClientResponseDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<LoginReputationClientResponse> _instance; +} _LoginReputationClientResponse_default_instance_; +class ClientMalwareResponseDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientMalwareResponse> _instance; +} _ClientMalwareResponse_default_instance_; +class ClientDownloadRequest_DigestsDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadRequest_Digests> _instance; +} _ClientDownloadRequest_Digests_default_instance_; +class ClientDownloadRequest_ResourceDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadRequest_Resource> _instance; +} _ClientDownloadRequest_Resource_default_instance_; +class ClientDownloadRequest_CertificateChain_ElementDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadRequest_CertificateChain_Element> _instance; +} _ClientDownloadRequest_CertificateChain_Element_default_instance_; +class ClientDownloadRequest_CertificateChainDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadRequest_CertificateChain> _instance; +} _ClientDownloadRequest_CertificateChain_default_instance_; +class ClientDownloadRequest_ExtendedAttrDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadRequest_ExtendedAttr> _instance; +} _ClientDownloadRequest_ExtendedAttr_default_instance_; +class ClientDownloadRequest_SignatureInfoDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadRequest_SignatureInfo> _instance; +} _ClientDownloadRequest_SignatureInfo_default_instance_; +class ClientDownloadRequest_PEImageHeaders_DebugDataDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadRequest_PEImageHeaders_DebugData> _instance; +} _ClientDownloadRequest_PEImageHeaders_DebugData_default_instance_; +class ClientDownloadRequest_PEImageHeadersDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadRequest_PEImageHeaders> _instance; +} _ClientDownloadRequest_PEImageHeaders_default_instance_; +class ClientDownloadRequest_MachOHeaders_LoadCommandDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadRequest_MachOHeaders_LoadCommand> _instance; +} _ClientDownloadRequest_MachOHeaders_LoadCommand_default_instance_; +class ClientDownloadRequest_MachOHeadersDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadRequest_MachOHeaders> _instance; +} _ClientDownloadRequest_MachOHeaders_default_instance_; +class ClientDownloadRequest_ImageHeadersDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadRequest_ImageHeaders> _instance; +} _ClientDownloadRequest_ImageHeaders_default_instance_; +class ClientDownloadRequest_ArchivedBinaryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadRequest_ArchivedBinary> _instance; +} _ClientDownloadRequest_ArchivedBinary_default_instance_; +class ClientDownloadRequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadRequest> _instance; +} _ClientDownloadRequest_default_instance_; +class ReferrerChainEntry_ServerRedirectDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ReferrerChainEntry_ServerRedirect> _instance; +} _ReferrerChainEntry_ServerRedirect_default_instance_; +class ReferrerChainEntryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ReferrerChainEntry> _instance; +} _ReferrerChainEntry_default_instance_; +class ClientDownloadResponse_MoreInfoDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadResponse_MoreInfo> _instance; +} _ClientDownloadResponse_MoreInfo_default_instance_; +class ClientDownloadResponseDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadResponse> _instance; +} _ClientDownloadResponse_default_instance_; +class ClientDownloadReport_UserInformationDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadReport_UserInformation> _instance; +} _ClientDownloadReport_UserInformation_default_instance_; +class ClientDownloadReportDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientDownloadReport> _instance; +} _ClientDownloadReport_default_instance_; +class ClientUploadResponseDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientUploadResponse> _instance; +} _ClientUploadResponse_default_instance_; +class ClientIncidentReport_IncidentData_TrackedPreferenceIncidentDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_IncidentData_TrackedPreferenceIncident> _instance; +} _ClientIncidentReport_IncidentData_TrackedPreferenceIncident_default_instance_; +class ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFileDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile> _instance; +} _ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_default_instance_; +class ClientIncidentReport_IncidentData_BinaryIntegrityIncidentDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_IncidentData_BinaryIntegrityIncident> _instance; +} _ClientIncidentReport_IncidentData_BinaryIntegrityIncident_default_instance_; +class ClientIncidentReport_IncidentData_ResourceRequestIncidentDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_IncidentData_ResourceRequestIncident> _instance; +} _ClientIncidentReport_IncidentData_ResourceRequestIncident_default_instance_; +class ClientIncidentReport_IncidentDataDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_IncidentData> _instance; +} _ClientIncidentReport_IncidentData_default_instance_; +class ClientIncidentReport_DownloadDetailsDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_DownloadDetails> _instance; +} _ClientIncidentReport_DownloadDetails_default_instance_; +class ClientIncidentReport_EnvironmentData_OS_RegistryValueDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_EnvironmentData_OS_RegistryValue> _instance; +} _ClientIncidentReport_EnvironmentData_OS_RegistryValue_default_instance_; +class ClientIncidentReport_EnvironmentData_OS_RegistryKeyDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_EnvironmentData_OS_RegistryKey> _instance; +} _ClientIncidentReport_EnvironmentData_OS_RegistryKey_default_instance_; +class ClientIncidentReport_EnvironmentData_OSDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_EnvironmentData_OS> _instance; +} _ClientIncidentReport_EnvironmentData_OS_default_instance_; +class ClientIncidentReport_EnvironmentData_MachineDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_EnvironmentData_Machine> _instance; +} _ClientIncidentReport_EnvironmentData_Machine_default_instance_; +class ClientIncidentReport_EnvironmentData_Process_PatchDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_EnvironmentData_Process_Patch> _instance; +} _ClientIncidentReport_EnvironmentData_Process_Patch_default_instance_; +class ClientIncidentReport_EnvironmentData_Process_NetworkProviderDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_EnvironmentData_Process_NetworkProvider> _instance; +} _ClientIncidentReport_EnvironmentData_Process_NetworkProvider_default_instance_; +class ClientIncidentReport_EnvironmentData_Process_DllDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_EnvironmentData_Process_Dll> _instance; +} _ClientIncidentReport_EnvironmentData_Process_Dll_default_instance_; +class ClientIncidentReport_EnvironmentData_Process_ModuleState_ModificationDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification> _instance; +} _ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification_default_instance_; +class ClientIncidentReport_EnvironmentData_Process_ModuleStateDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_EnvironmentData_Process_ModuleState> _instance; +} _ClientIncidentReport_EnvironmentData_Process_ModuleState_default_instance_; +class ClientIncidentReport_EnvironmentData_ProcessDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_EnvironmentData_Process> _instance; +} _ClientIncidentReport_EnvironmentData_Process_default_instance_; +class ClientIncidentReport_EnvironmentDataDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_EnvironmentData> _instance; +} _ClientIncidentReport_EnvironmentData_default_instance_; +class ClientIncidentReport_ExtensionData_ExtensionInfoDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_ExtensionData_ExtensionInfo> _instance; +} _ClientIncidentReport_ExtensionData_ExtensionInfo_default_instance_; +class ClientIncidentReport_ExtensionDataDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_ExtensionData> _instance; +} _ClientIncidentReport_ExtensionData_default_instance_; +class ClientIncidentReport_NonBinaryDownloadDetailsDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport_NonBinaryDownloadDetails> _instance; +} _ClientIncidentReport_NonBinaryDownloadDetails_default_instance_; +class ClientIncidentReportDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentReport> _instance; +} _ClientIncidentReport_default_instance_; +class ClientIncidentResponse_EnvironmentRequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentResponse_EnvironmentRequest> _instance; +} _ClientIncidentResponse_EnvironmentRequest_default_instance_; +class ClientIncidentResponseDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientIncidentResponse> _instance; +} _ClientIncidentResponse_default_instance_; +class DownloadMetadataDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DownloadMetadata> _instance; +} _DownloadMetadata_default_instance_; +class ClientSafeBrowsingReportRequest_HTTPHeaderDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientSafeBrowsingReportRequest_HTTPHeader> _instance; +} _ClientSafeBrowsingReportRequest_HTTPHeader_default_instance_; +class ClientSafeBrowsingReportRequest_HTTPRequest_FirstLineDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine> _instance; +} _ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_default_instance_; +class ClientSafeBrowsingReportRequest_HTTPRequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientSafeBrowsingReportRequest_HTTPRequest> _instance; +} _ClientSafeBrowsingReportRequest_HTTPRequest_default_instance_; +class ClientSafeBrowsingReportRequest_HTTPResponse_FirstLineDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine> _instance; +} _ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_default_instance_; +class ClientSafeBrowsingReportRequest_HTTPResponseDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientSafeBrowsingReportRequest_HTTPResponse> _instance; +} _ClientSafeBrowsingReportRequest_HTTPResponse_default_instance_; +class ClientSafeBrowsingReportRequest_ResourceDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientSafeBrowsingReportRequest_Resource> _instance; +} _ClientSafeBrowsingReportRequest_Resource_default_instance_; +class ClientSafeBrowsingReportRequest_SafeBrowsingClientPropertiesDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties> _instance; +} _ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_default_instance_; +class ClientSafeBrowsingReportRequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ClientSafeBrowsingReportRequest> _instance; +} _ClientSafeBrowsingReportRequest_default_instance_; +class HTMLElement_AttributeDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<HTMLElement_Attribute> _instance; +} _HTMLElement_Attribute_default_instance_; +class HTMLElementDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<HTMLElement> _instance; +} _HTMLElement_default_instance_; +class ImageData_DimensionsDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ImageData_Dimensions> _instance; +} _ImageData_Dimensions_default_instance_; +class ImageDataDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ImageData> _instance; +} _ImageData_default_instance_; +class NotificationImageReportRequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<NotificationImageReportRequest> _instance; +} _NotificationImageReportRequest_default_instance_; +} // namespace safe_browsing +static void InitDefaultsscc_info_ChromeUserPopulation_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ChromeUserPopulation_default_instance_; + new (ptr) ::safe_browsing::ChromeUserPopulation(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ChromeUserPopulation::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ChromeUserPopulation_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ChromeUserPopulation_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientDownloadReport_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadReport_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadReport(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadReport::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ClientDownloadReport_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_ClientDownloadReport_csd_2eproto}, { + &scc_info_ClientDownloadRequest_csd_2eproto.base, + &scc_info_ClientDownloadReport_UserInformation_csd_2eproto.base, + &scc_info_ClientDownloadResponse_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientDownloadReport_UserInformation_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadReport_UserInformation_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadReport_UserInformation(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadReport_UserInformation::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadReport_UserInformation_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientDownloadReport_UserInformation_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientDownloadRequest_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadRequest_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadRequest(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadRequest::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<7> scc_info_ClientDownloadRequest_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 7, 0, InitDefaultsscc_info_ClientDownloadRequest_csd_2eproto}, { + &scc_info_ClientDownloadRequest_Digests_csd_2eproto.base, + &scc_info_ClientDownloadRequest_Resource_csd_2eproto.base, + &scc_info_ClientDownloadRequest_SignatureInfo_csd_2eproto.base, + &scc_info_ClientDownloadRequest_ImageHeaders_csd_2eproto.base, + &scc_info_ClientDownloadRequest_ArchivedBinary_csd_2eproto.base, + &scc_info_ChromeUserPopulation_csd_2eproto.base, + &scc_info_ReferrerChainEntry_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientDownloadRequest_ArchivedBinary_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadRequest_ArchivedBinary_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadRequest_ArchivedBinary(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadRequest_ArchivedBinary::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ClientDownloadRequest_ArchivedBinary_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_ClientDownloadRequest_ArchivedBinary_csd_2eproto}, { + &scc_info_ClientDownloadRequest_Digests_csd_2eproto.base, + &scc_info_ClientDownloadRequest_SignatureInfo_csd_2eproto.base, + &scc_info_ClientDownloadRequest_ImageHeaders_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientDownloadRequest_CertificateChain_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadRequest_CertificateChain_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadRequest_CertificateChain(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadRequest_CertificateChain::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientDownloadRequest_CertificateChain_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ClientDownloadRequest_CertificateChain_csd_2eproto}, { + &scc_info_ClientDownloadRequest_CertificateChain_Element_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientDownloadRequest_CertificateChain_Element_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadRequest_CertificateChain_Element_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadRequest_CertificateChain_Element(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadRequest_CertificateChain_Element::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadRequest_CertificateChain_Element_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientDownloadRequest_CertificateChain_Element_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientDownloadRequest_Digests_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadRequest_Digests_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadRequest_Digests(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadRequest_Digests::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadRequest_Digests_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientDownloadRequest_Digests_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientDownloadRequest_ExtendedAttr_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadRequest_ExtendedAttr_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadRequest_ExtendedAttr(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadRequest_ExtendedAttr::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadRequest_ExtendedAttr_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientDownloadRequest_ExtendedAttr_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientDownloadRequest_ImageHeaders_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadRequest_ImageHeaders_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadRequest_ImageHeaders(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadRequest_ImageHeaders::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientDownloadRequest_ImageHeaders_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ClientDownloadRequest_ImageHeaders_csd_2eproto}, { + &scc_info_ClientDownloadRequest_PEImageHeaders_csd_2eproto.base, + &scc_info_ClientDownloadRequest_MachOHeaders_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientDownloadRequest_MachOHeaders_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadRequest_MachOHeaders_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadRequest_MachOHeaders(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadRequest_MachOHeaders::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientDownloadRequest_MachOHeaders_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ClientDownloadRequest_MachOHeaders_csd_2eproto}, { + &scc_info_ClientDownloadRequest_MachOHeaders_LoadCommand_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientDownloadRequest_MachOHeaders_LoadCommand_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadRequest_MachOHeaders_LoadCommand_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadRequest_MachOHeaders_LoadCommand_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientDownloadRequest_MachOHeaders_LoadCommand_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientDownloadRequest_PEImageHeaders_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadRequest_PEImageHeaders_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadRequest_PEImageHeaders(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadRequest_PEImageHeaders::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientDownloadRequest_PEImageHeaders_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ClientDownloadRequest_PEImageHeaders_csd_2eproto}, { + &scc_info_ClientDownloadRequest_PEImageHeaders_DebugData_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientDownloadRequest_PEImageHeaders_DebugData_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadRequest_PEImageHeaders_DebugData_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadRequest_PEImageHeaders_DebugData_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientDownloadRequest_PEImageHeaders_DebugData_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientDownloadRequest_Resource_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadRequest_Resource_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadRequest_Resource(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadRequest_Resource::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadRequest_Resource_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientDownloadRequest_Resource_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientDownloadRequest_SignatureInfo_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadRequest_SignatureInfo_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadRequest_SignatureInfo(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadRequest_SignatureInfo::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientDownloadRequest_SignatureInfo_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ClientDownloadRequest_SignatureInfo_csd_2eproto}, { + &scc_info_ClientDownloadRequest_CertificateChain_csd_2eproto.base, + &scc_info_ClientDownloadRequest_ExtendedAttr_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientDownloadResponse_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadResponse_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadResponse(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadResponse::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientDownloadResponse_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ClientDownloadResponse_csd_2eproto}, { + &scc_info_ClientDownloadResponse_MoreInfo_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientDownloadResponse_MoreInfo_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientDownloadResponse_MoreInfo_default_instance_; + new (ptr) ::safe_browsing::ClientDownloadResponse_MoreInfo(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientDownloadResponse_MoreInfo::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientDownloadResponse_MoreInfo_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientDownloadResponse_MoreInfo_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientIncidentReport_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<6> scc_info_ClientIncidentReport_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 6, 0, InitDefaultsscc_info_ClientIncidentReport_csd_2eproto}, { + &scc_info_ClientIncidentReport_IncidentData_csd_2eproto.base, + &scc_info_ClientIncidentReport_DownloadDetails_csd_2eproto.base, + &scc_info_ClientIncidentReport_EnvironmentData_csd_2eproto.base, + &scc_info_ChromeUserPopulation_csd_2eproto.base, + &scc_info_ClientIncidentReport_ExtensionData_csd_2eproto.base, + &scc_info_ClientIncidentReport_NonBinaryDownloadDetails_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientIncidentReport_DownloadDetails_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_DownloadDetails_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_DownloadDetails(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_DownloadDetails::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientIncidentReport_DownloadDetails_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ClientIncidentReport_DownloadDetails_csd_2eproto}, { + &scc_info_ClientDownloadRequest_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_EnvironmentData_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_EnvironmentData(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_EnvironmentData::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ClientIncidentReport_EnvironmentData_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_csd_2eproto}, { + &scc_info_ClientIncidentReport_EnvironmentData_OS_csd_2eproto.base, + &scc_info_ClientIncidentReport_EnvironmentData_Machine_csd_2eproto.base, + &scc_info_ClientIncidentReport_EnvironmentData_Process_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Machine_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_EnvironmentData_Machine_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_EnvironmentData_Machine_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Machine_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_OS_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_EnvironmentData_OS_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_EnvironmentData_OS(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_EnvironmentData_OS::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientIncidentReport_EnvironmentData_OS_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_OS_csd_2eproto}, { + &scc_info_ClientIncidentReport_EnvironmentData_OS_RegistryKey_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_OS_RegistryKey_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_EnvironmentData_OS_RegistryKey_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientIncidentReport_EnvironmentData_OS_RegistryKey_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_OS_RegistryKey_csd_2eproto}, { + &scc_info_ClientIncidentReport_EnvironmentData_OS_RegistryValue_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_OS_RegistryValue_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_EnvironmentData_OS_RegistryValue_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_EnvironmentData_OS_RegistryValue_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_OS_RegistryValue_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Process_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_EnvironmentData_Process_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_EnvironmentData_Process(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_EnvironmentData_Process::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_ClientIncidentReport_EnvironmentData_Process_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 4, 0, InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Process_csd_2eproto}, { + &scc_info_ClientIncidentReport_EnvironmentData_Process_Patch_csd_2eproto.base, + &scc_info_ClientIncidentReport_EnvironmentData_Process_NetworkProvider_csd_2eproto.base, + &scc_info_ClientIncidentReport_EnvironmentData_Process_Dll_csd_2eproto.base, + &scc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Process_Dll_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_EnvironmentData_Process_Dll_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientIncidentReport_EnvironmentData_Process_Dll_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Process_Dll_csd_2eproto}, { + &scc_info_ClientDownloadRequest_ImageHeaders_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_EnvironmentData_Process_ModuleState_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_csd_2eproto}, { + &scc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Process_NetworkProvider_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_EnvironmentData_Process_NetworkProvider_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_EnvironmentData_Process_NetworkProvider_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Process_NetworkProvider_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Process_Patch_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_EnvironmentData_Process_Patch_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_EnvironmentData_Process_Patch_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientIncidentReport_EnvironmentData_Process_Patch_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientIncidentReport_ExtensionData_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_ExtensionData_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_ExtensionData(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_ExtensionData::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientIncidentReport_ExtensionData_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ClientIncidentReport_ExtensionData_csd_2eproto}, { + &scc_info_ClientIncidentReport_ExtensionData_ExtensionInfo_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientIncidentReport_ExtensionData_ExtensionInfo_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_ExtensionData_ExtensionInfo_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_ExtensionData_ExtensionInfo_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientIncidentReport_ExtensionData_ExtensionInfo_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientIncidentReport_IncidentData_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_IncidentData_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_IncidentData(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_IncidentData::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ClientIncidentReport_IncidentData_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_ClientIncidentReport_IncidentData_csd_2eproto}, { + &scc_info_ClientIncidentReport_IncidentData_TrackedPreferenceIncident_csd_2eproto.base, + &scc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_csd_2eproto.base, + &scc_info_ClientIncidentReport_IncidentData_ResourceRequestIncident_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_csd_2eproto}, { + &scc_info_ClientDownloadRequest_SignatureInfo_csd_2eproto.base, + &scc_info_ClientDownloadRequest_ImageHeaders_csd_2eproto.base, + &scc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_csd_2eproto}, { + &scc_info_ClientDownloadRequest_SignatureInfo_csd_2eproto.base, + &scc_info_ClientDownloadRequest_ImageHeaders_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientIncidentReport_IncidentData_ResourceRequestIncident_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_IncidentData_ResourceRequestIncident_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_IncidentData_ResourceRequestIncident_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientIncidentReport_IncidentData_ResourceRequestIncident_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientIncidentReport_IncidentData_TrackedPreferenceIncident_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_IncidentData_TrackedPreferenceIncident_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_IncidentData_TrackedPreferenceIncident_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientIncidentReport_IncidentData_TrackedPreferenceIncident_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientIncidentReport_NonBinaryDownloadDetails_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentReport_NonBinaryDownloadDetails_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentReport_NonBinaryDownloadDetails_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientIncidentReport_NonBinaryDownloadDetails_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientIncidentResponse_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentResponse_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentResponse(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentResponse::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ClientIncidentResponse_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ClientIncidentResponse_csd_2eproto}, { + &scc_info_ClientIncidentResponse_EnvironmentRequest_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientIncidentResponse_EnvironmentRequest_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientIncidentResponse_EnvironmentRequest_default_instance_; + new (ptr) ::safe_browsing::ClientIncidentResponse_EnvironmentRequest(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientIncidentResponse_EnvironmentRequest::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientIncidentResponse_EnvironmentRequest_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientIncidentResponse_EnvironmentRequest_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientMalwareRequest_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientMalwareRequest_default_instance_; + new (ptr) ::safe_browsing::ClientMalwareRequest(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientMalwareRequest::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientMalwareRequest_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ClientMalwareRequest_csd_2eproto}, { + &scc_info_ClientMalwareRequest_UrlInfo_csd_2eproto.base, + &scc_info_ChromeUserPopulation_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientMalwareRequest_UrlInfo_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientMalwareRequest_UrlInfo_default_instance_; + new (ptr) ::safe_browsing::ClientMalwareRequest_UrlInfo(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientMalwareRequest_UrlInfo::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientMalwareRequest_UrlInfo_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientMalwareRequest_UrlInfo_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientMalwareResponse_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientMalwareResponse_default_instance_; + new (ptr) ::safe_browsing::ClientMalwareResponse(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientMalwareResponse::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientMalwareResponse_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientMalwareResponse_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientPhishingRequest_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientPhishingRequest_default_instance_; + new (ptr) ::safe_browsing::ClientPhishingRequest(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientPhishingRequest::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientPhishingRequest_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ClientPhishingRequest_csd_2eproto}, { + &scc_info_ClientPhishingRequest_Feature_csd_2eproto.base, + &scc_info_ChromeUserPopulation_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientPhishingRequest_Feature_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientPhishingRequest_Feature_default_instance_; + new (ptr) ::safe_browsing::ClientPhishingRequest_Feature(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientPhishingRequest_Feature::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientPhishingRequest_Feature_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientPhishingRequest_Feature_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientPhishingResponse_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientPhishingResponse_default_instance_; + new (ptr) ::safe_browsing::ClientPhishingResponse(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientPhishingResponse::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientPhishingResponse_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientPhishingResponse_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientSafeBrowsingReportRequest_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientSafeBrowsingReportRequest_default_instance_; + new (ptr) ::safe_browsing::ClientSafeBrowsingReportRequest(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientSafeBrowsingReportRequest::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_ClientSafeBrowsingReportRequest_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_ClientSafeBrowsingReportRequest_csd_2eproto}, { + &scc_info_ClientSafeBrowsingReportRequest_Resource_csd_2eproto.base, + &scc_info_HTMLElement_csd_2eproto.base, + &scc_info_ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientSafeBrowsingReportRequest_HTTPHeader_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientSafeBrowsingReportRequest_HTTPHeader_default_instance_; + new (ptr) ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientSafeBrowsingReportRequest_HTTPHeader_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientSafeBrowsingReportRequest_HTTPHeader_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientSafeBrowsingReportRequest_HTTPRequest_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientSafeBrowsingReportRequest_HTTPRequest_default_instance_; + new (ptr) ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientSafeBrowsingReportRequest_HTTPRequest_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ClientSafeBrowsingReportRequest_HTTPRequest_csd_2eproto}, { + &scc_info_ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_csd_2eproto.base, + &scc_info_ClientSafeBrowsingReportRequest_HTTPHeader_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_default_instance_; + new (ptr) ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientSafeBrowsingReportRequest_HTTPResponse_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientSafeBrowsingReportRequest_HTTPResponse_default_instance_; + new (ptr) ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientSafeBrowsingReportRequest_HTTPResponse_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ClientSafeBrowsingReportRequest_HTTPResponse_csd_2eproto}, { + &scc_info_ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_csd_2eproto.base, + &scc_info_ClientSafeBrowsingReportRequest_HTTPHeader_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_default_instance_; + new (ptr) ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientSafeBrowsingReportRequest_Resource_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientSafeBrowsingReportRequest_Resource_default_instance_; + new (ptr) ::safe_browsing::ClientSafeBrowsingReportRequest_Resource(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientSafeBrowsingReportRequest_Resource::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_ClientSafeBrowsingReportRequest_Resource_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_ClientSafeBrowsingReportRequest_Resource_csd_2eproto}, { + &scc_info_ClientSafeBrowsingReportRequest_HTTPRequest_csd_2eproto.base, + &scc_info_ClientSafeBrowsingReportRequest_HTTPResponse_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_default_instance_; + new (ptr) ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ClientUploadResponse_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ClientUploadResponse_default_instance_; + new (ptr) ::safe_browsing::ClientUploadResponse(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ClientUploadResponse::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ClientUploadResponse_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ClientUploadResponse_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_DownloadMetadata_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_DownloadMetadata_default_instance_; + new (ptr) ::safe_browsing::DownloadMetadata(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::DownloadMetadata::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_DownloadMetadata_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_DownloadMetadata_csd_2eproto}, { + &scc_info_ClientIncidentReport_DownloadDetails_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_HTMLElement_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_HTMLElement_default_instance_; + new (ptr) ::safe_browsing::HTMLElement(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::HTMLElement::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_HTMLElement_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_HTMLElement_csd_2eproto}, { + &scc_info_HTMLElement_Attribute_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_HTMLElement_Attribute_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_HTMLElement_Attribute_default_instance_; + new (ptr) ::safe_browsing::HTMLElement_Attribute(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::HTMLElement_Attribute::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HTMLElement_Attribute_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_HTMLElement_Attribute_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_ImageData_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ImageData_default_instance_; + new (ptr) ::safe_browsing::ImageData(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ImageData::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ImageData_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ImageData_csd_2eproto}, { + &scc_info_ImageData_Dimensions_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ImageData_Dimensions_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ImageData_Dimensions_default_instance_; + new (ptr) ::safe_browsing::ImageData_Dimensions(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ImageData_Dimensions::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ImageData_Dimensions_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ImageData_Dimensions_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_LoginReputationClientRequest_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_LoginReputationClientRequest_default_instance_; + new (ptr) ::safe_browsing::LoginReputationClientRequest(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::LoginReputationClientRequest::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_LoginReputationClientRequest_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_LoginReputationClientRequest_csd_2eproto}, { + &scc_info_LoginReputationClientRequest_Frame_csd_2eproto.base, + &scc_info_LoginReputationClientRequest_PasswordReuseEvent_csd_2eproto.base, + &scc_info_ChromeUserPopulation_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_LoginReputationClientRequest_Frame_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_LoginReputationClientRequest_Frame_default_instance_; + new (ptr) ::safe_browsing::LoginReputationClientRequest_Frame(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::LoginReputationClientRequest_Frame::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_LoginReputationClientRequest_Frame_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_LoginReputationClientRequest_Frame_csd_2eproto}, { + &scc_info_ReferrerChainEntry_csd_2eproto.base, + &scc_info_LoginReputationClientRequest_Frame_Form_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_LoginReputationClientRequest_Frame_Form_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_LoginReputationClientRequest_Frame_Form_default_instance_; + new (ptr) ::safe_browsing::LoginReputationClientRequest_Frame_Form(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::LoginReputationClientRequest_Frame_Form::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LoginReputationClientRequest_Frame_Form_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_LoginReputationClientRequest_Frame_Form_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_LoginReputationClientRequest_PasswordReuseEvent_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_LoginReputationClientRequest_PasswordReuseEvent_default_instance_; + new (ptr) ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LoginReputationClientRequest_PasswordReuseEvent_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_LoginReputationClientRequest_PasswordReuseEvent_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_LoginReputationClientResponse_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_LoginReputationClientResponse_default_instance_; + new (ptr) ::safe_browsing::LoginReputationClientResponse(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::LoginReputationClientResponse::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LoginReputationClientResponse_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_LoginReputationClientResponse_csd_2eproto}, {}}; + +static void InitDefaultsscc_info_NotificationImageReportRequest_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_NotificationImageReportRequest_default_instance_; + new (ptr) ::safe_browsing::NotificationImageReportRequest(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::NotificationImageReportRequest::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_NotificationImageReportRequest_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_NotificationImageReportRequest_csd_2eproto}, { + &scc_info_ImageData_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ReferrerChainEntry_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ReferrerChainEntry_default_instance_; + new (ptr) ::safe_browsing::ReferrerChainEntry(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ReferrerChainEntry::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_ReferrerChainEntry_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_ReferrerChainEntry_csd_2eproto}, { + &scc_info_ReferrerChainEntry_ServerRedirect_csd_2eproto.base,}}; + +static void InitDefaultsscc_info_ReferrerChainEntry_ServerRedirect_csd_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::safe_browsing::_ReferrerChainEntry_ServerRedirect_default_instance_; + new (ptr) ::safe_browsing::ReferrerChainEntry_ServerRedirect(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::safe_browsing::ReferrerChainEntry_ServerRedirect::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ReferrerChainEntry_ServerRedirect_csd_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_ReferrerChainEntry_ServerRedirect_csd_2eproto}, {}}; + +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) +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( + const std::string& 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) +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) + +// =================================================================== + +void ChromeUserPopulation::InitAsDefaultInstance() { +} +class ChromeUserPopulation::_Internal { + public: + using HasBits = decltype(std::declval<ChromeUserPopulation>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ChromeUserPopulation) +} +ChromeUserPopulation::ChromeUserPopulation(const ChromeUserPopulation& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + finch_active_groups_(from.finch_active_groups_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&user_population_, &from.user_population_, + static_cast<size_t>(reinterpret_cast<char*>(&is_history_sync_enabled_) - + reinterpret_cast<char*>(&user_population_)) + sizeof(is_history_sync_enabled_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ChromeUserPopulation) +} + +void ChromeUserPopulation::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ChromeUserPopulation_csd_2eproto.base); + ::memset(&user_population_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&is_history_sync_enabled_) - + reinterpret_cast<char*>(&user_population_)) + sizeof(is_history_sync_enabled_)); +} + +ChromeUserPopulation::~ChromeUserPopulation() { + // @@protoc_insertion_point(destructor:safe_browsing.ChromeUserPopulation) + SharedDtor(); +} + +void ChromeUserPopulation::SharedDtor() { +} + +void ChromeUserPopulation::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ChromeUserPopulation& ChromeUserPopulation::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ChromeUserPopulation_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ChromeUserPopulation::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ChromeUserPopulation) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + finch_active_groups_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&user_population_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&is_history_sync_enabled_) - + reinterpret_cast<char*>(&user_population_)) + sizeof(is_history_sync_enabled_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ChromeUserPopulation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional .safe_browsing.ChromeUserPopulation.UserPopulation user_population = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_is_history_sync_enabled(&has_bits); + is_history_sync_enabled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string finch_active_groups = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_finch_active_groups(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ChromeUserPopulation::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ChromeUserPopulation) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .safe_browsing.ChromeUserPopulation.UserPopulation user_population = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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(finch_active_groups_.size()); + for (int i = 0, n = finch_active_groups_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + finch_active_groups_.Get(i)); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .safe_browsing.ChromeUserPopulation.UserPopulation user_population = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ChromeUserPopulation::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ChromeUserPopulation*>( + &from)); +} + +void ChromeUserPopulation::MergeFrom(const ChromeUserPopulation& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ChromeUserPopulation) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + finch_active_groups_.MergeFrom(from.finch_active_groups_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + user_population_ = from.user_population_; + } + if (cached_has_bits & 0x00000002u) { + is_history_sync_enabled_ = from.is_history_sync_enabled_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + finch_active_groups_.InternalSwap(&other->finch_active_groups_); + swap(user_population_, other->user_population_); + swap(is_history_sync_enabled_, other->is_history_sync_enabled_); +} + +std::string ChromeUserPopulation::GetTypeName() const { + return "safe_browsing.ChromeUserPopulation"; +} + + +// =================================================================== + +void ClientPhishingRequest_Feature::InitAsDefaultInstance() { +} +class ClientPhishingRequest_Feature::_Internal { + public: + using HasBits = decltype(std::declval<ClientPhishingRequest_Feature>()._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; + } +}; + +ClientPhishingRequest_Feature::ClientPhishingRequest_Feature() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientPhishingRequest.Feature) +} +ClientPhishingRequest_Feature::ClientPhishingRequest_Feature(const ClientPhishingRequest_Feature& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + value_ = from.value_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientPhishingRequest.Feature) +} + +void ClientPhishingRequest_Feature::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientPhishingRequest_Feature_csd_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_ = 0; +} + +ClientPhishingRequest_Feature::~ClientPhishingRequest_Feature() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientPhishingRequest.Feature) + SharedDtor(); +} + +void ClientPhishingRequest_Feature::SharedDtor() { + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientPhishingRequest_Feature::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientPhishingRequest_Feature& ClientPhishingRequest_Feature::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientPhishingRequest_Feature_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientPhishingRequest_Feature::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientPhishingRequest.Feature) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmptyNoArena(); + } + value_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientPhishingRequest_Feature::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required double value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) { + _Internal::set_has_value(&has_bits); + value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr); + ptr += sizeof(double); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientPhishingRequest_Feature::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientPhishingRequest.Feature) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_value(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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 (((_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(); + } + ::PROTOBUF_NAMESPACE_ID::uint32 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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientPhishingRequest_Feature::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientPhishingRequest_Feature*>( + &from)); +} + +void ClientPhishingRequest_Feature::MergeFrom(const ClientPhishingRequest_Feature& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientPhishingRequest.Feature) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (cached_has_bits & 0x00000002u) { + value_ = from.value_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + return true; +} + +void ClientPhishingRequest_Feature::InternalSwap(ClientPhishingRequest_Feature* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(value_, other->value_); +} + +std::string ClientPhishingRequest_Feature::GetTypeName() const { + return "safe_browsing.ClientPhishingRequest.Feature"; +} + + +// =================================================================== + +void ClientPhishingRequest::InitAsDefaultInstance() { + ::safe_browsing::_ClientPhishingRequest_default_instance_._instance.get_mutable()->population_ = const_cast< ::safe_browsing::ChromeUserPopulation*>( + ::safe_browsing::ChromeUserPopulation::internal_default_instance()); +} +class ClientPhishingRequest::_Internal { + public: + using HasBits = decltype(std::declval<ClientPhishingRequest>()._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; + } +}; + +const ::safe_browsing::ChromeUserPopulation& +ClientPhishingRequest::_Internal::population(const ClientPhishingRequest* msg) { + return *msg->population_; +} +ClientPhishingRequest::ClientPhishingRequest() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientPhishingRequest) +} +ClientPhishingRequest::ClientPhishingRequest(const ClientPhishingRequest& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + feature_map_(from.feature_map_), + non_model_feature_map_(from.non_model_feature_map_), + shingle_hashes_(from.shingle_hashes_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_url()) { + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + obsolete_referrer_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_obsolete_referrer_url()) { + obsolete_referrer_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.obsolete_referrer_url_); + } + obsolete_hash_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_obsolete_hash_prefix()) { + obsolete_hash_prefix_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.obsolete_hash_prefix_); + } + model_filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_model_filename()) { + model_filename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.model_filename_); + } + if (from._internal_has_population()) { + population_ = new ::safe_browsing::ChromeUserPopulation(*from.population_); + } else { + population_ = nullptr; + } + ::memcpy(&client_score_, &from.client_score_, + static_cast<size_t>(reinterpret_cast<char*>(&model_version_) - + reinterpret_cast<char*>(&client_score_)) + sizeof(model_version_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientPhishingRequest) +} + +void ClientPhishingRequest::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientPhishingRequest_csd_2eproto.base); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + obsolete_referrer_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + obsolete_hash_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + model_filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&population_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&model_version_) - + reinterpret_cast<char*>(&population_)) + sizeof(model_version_)); +} + +ClientPhishingRequest::~ClientPhishingRequest() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientPhishingRequest) + SharedDtor(); +} + +void ClientPhishingRequest::SharedDtor() { + url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + obsolete_referrer_url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + obsolete_hash_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + model_filename_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete population_; +} + +void ClientPhishingRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientPhishingRequest& ClientPhishingRequest::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientPhishingRequest_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientPhishingRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientPhishingRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + feature_map_.Clear(); + non_model_feature_map_.Clear(); + shingle_hashes_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + obsolete_referrer_url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + obsolete_hash_prefix_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000008u) { + model_filename_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(population_ != nullptr); + population_->Clear(); + } + } + if (cached_has_bits & 0x000000e0u) { + ::memset(&client_score_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&model_version_) - + reinterpret_cast<char*>(&client_score_)) + sizeof(model_version_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientPhishingRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required float client_score = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + _Internal::set_has_client_score(&has_bits); + 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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_is_phishing(&has_bits); + is_phishing_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + _Internal::set_has_model_version(&has_bits); + model_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + auto str = _internal_mutable_obsolete_referrer_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + auto str = _internal_mutable_obsolete_hash_prefix(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_shingle_hashes(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96) { + _internal_add_shingle_hashes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string model_filename = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + auto str = _internal_mutable_model_filename(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_population(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientPhishingRequest::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientPhishingRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_client_score(), target); + } + + // optional bool is_phishing = 4; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_is_phishing(), target); + } + + // repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_feature_map_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, this->_internal_feature_map(i), target, stream); + } + + // optional int32 model_version = 6; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(6, this->_internal_model_version(), target); + } + + // repeated .safe_browsing.ClientPhishingRequest.Feature non_model_feature_map = 8; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_non_model_feature_map_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, this->_internal_non_model_feature_map(i), 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 = _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 = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 14, _Internal::population(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + } + ::PROTOBUF_NAMESPACE_ID::uint32 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->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->non_model_feature_map_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated uint32 shingle_hashes = 12 [packed = true]; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + UInt32Size(this->shingle_hashes_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _shingle_hashes_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + cached_has_bits = _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( + *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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_model_version()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientPhishingRequest::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientPhishingRequest*>( + &from)); +} + +void ClientPhishingRequest::MergeFrom(const ClientPhishingRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientPhishingRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + feature_map_.MergeFrom(from.feature_map_); + non_model_feature_map_.MergeFrom(from.non_model_feature_map_); + shingle_hashes_.MergeFrom(from.shingle_hashes_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + obsolete_referrer_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.obsolete_referrer_url_); + } + if (cached_has_bits & 0x00000004u) { + _has_bits_[0] |= 0x00000004u; + obsolete_hash_prefix_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.obsolete_hash_prefix_); + } + if (cached_has_bits & 0x00000008u) { + _has_bits_[0] |= 0x00000008u; + model_filename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.model_filename_); + } + if (cached_has_bits & 0x00000010u) { + _internal_mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(from._internal_population()); + } + if (cached_has_bits & 0x00000020u) { + client_score_ = from.client_score_; + } + if (cached_has_bits & 0x00000040u) { + is_phishing_ = from.is_phishing_; + } + if (cached_has_bits & 0x00000080u) { + model_version_ = from.model_version_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 ((_has_bits_[0] & 0x00000020) != 0x00000020) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(feature_map_)) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(non_model_feature_map_)) return false; + return true; +} + +void ClientPhishingRequest::InternalSwap(ClientPhishingRequest* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + feature_map_.InternalSwap(&other->feature_map_); + non_model_feature_map_.InternalSwap(&other->non_model_feature_map_); + shingle_hashes_.InternalSwap(&other->shingle_hashes_); + url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + obsolete_referrer_url_.Swap(&other->obsolete_referrer_url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + obsolete_hash_prefix_.Swap(&other->obsolete_hash_prefix_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + model_filename_.Swap(&other->model_filename_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(population_, other->population_); + swap(client_score_, other->client_score_); + swap(is_phishing_, other->is_phishing_); + swap(model_version_, other->model_version_); +} + +std::string ClientPhishingRequest::GetTypeName() const { + return "safe_browsing.ClientPhishingRequest"; +} + + +// =================================================================== + +void ClientPhishingResponse::InitAsDefaultInstance() { +} +class ClientPhishingResponse::_Internal { + public: + using HasBits = decltype(std::declval<ClientPhishingResponse>()._has_bits_); + static void set_has_phishy(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ClientPhishingResponse::ClientPhishingResponse() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientPhishingResponse) +} +ClientPhishingResponse::ClientPhishingResponse(const ClientPhishingResponse& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + obsolete_whitelist_expression_(from.obsolete_whitelist_expression_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + phishy_ = from.phishy_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientPhishingResponse) +} + +void ClientPhishingResponse::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientPhishingResponse_csd_2eproto.base); + phishy_ = false; +} + +ClientPhishingResponse::~ClientPhishingResponse() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientPhishingResponse) + SharedDtor(); +} + +void ClientPhishingResponse::SharedDtor() { +} + +void ClientPhishingResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientPhishingResponse& ClientPhishingResponse::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientPhishingResponse_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientPhishingResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientPhishingResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + obsolete_whitelist_expression_.Clear(); + phishy_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientPhishingResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required bool phishy = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_phishy(&has_bits); + phishy_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string OBSOLETE_whitelist_expression = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_obsolete_whitelist_expression(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientPhishingResponse::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientPhishingResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required bool phishy = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + } + ::PROTOBUF_NAMESPACE_ID::uint32 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(obsolete_whitelist_expression_.size()); + for (int i = 0, n = obsolete_whitelist_expression_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + obsolete_whitelist_expression_.Get(i)); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientPhishingResponse::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientPhishingResponse*>( + &from)); +} + +void ClientPhishingResponse::MergeFrom(const ClientPhishingResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientPhishingResponse) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + obsolete_whitelist_expression_.MergeFrom(from.obsolete_whitelist_expression_); + if (from._internal_has_phishy()) { + _internal_set_phishy(from._internal_phishy()); + } +} + +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 ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + return true; +} + +void ClientPhishingResponse::InternalSwap(ClientPhishingResponse* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + obsolete_whitelist_expression_.InternalSwap(&other->obsolete_whitelist_expression_); + swap(phishy_, other->phishy_); +} + +std::string ClientPhishingResponse::GetTypeName() const { + return "safe_browsing.ClientPhishingResponse"; +} + + +// =================================================================== + +void ClientMalwareRequest_UrlInfo::InitAsDefaultInstance() { +} +class ClientMalwareRequest_UrlInfo::_Internal { + public: + using HasBits = decltype(std::declval<ClientMalwareRequest_UrlInfo>()._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; + } +}; + +ClientMalwareRequest_UrlInfo::ClientMalwareRequest_UrlInfo() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientMalwareRequest.UrlInfo) +} +ClientMalwareRequest_UrlInfo::ClientMalwareRequest_UrlInfo(const ClientMalwareRequest_UrlInfo& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_ip()) { + ip_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.ip_); + } + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_url()) { + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + method_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_method()) { + method_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.method_); + } + referrer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_referrer()) { + referrer_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_); + } + resource_type_ = from.resource_type_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientMalwareRequest.UrlInfo) +} + +void ClientMalwareRequest_UrlInfo::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientMalwareRequest_UrlInfo_csd_2eproto.base); + ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + method_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + referrer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + resource_type_ = 0; +} + +ClientMalwareRequest_UrlInfo::~ClientMalwareRequest_UrlInfo() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientMalwareRequest.UrlInfo) + SharedDtor(); +} + +void ClientMalwareRequest_UrlInfo::SharedDtor() { + ip_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + method_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + referrer_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientMalwareRequest_UrlInfo::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientMalwareRequest_UrlInfo& ClientMalwareRequest_UrlInfo::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientMalwareRequest_UrlInfo_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientMalwareRequest_UrlInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientMalwareRequest.UrlInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + ip_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + method_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000008u) { + referrer_.ClearNonDefaultToEmptyNoArena(); + } + } + resource_type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientMalwareRequest_UrlInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required string ip = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_ip(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required string url = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string method = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_method(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string referrer = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_referrer(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional int32 resource_type = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_resource_type(&has_bits); + resource_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientMalwareRequest_UrlInfo::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientMalwareRequest.UrlInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_resource_type(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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 (((_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(); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_resource_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientMalwareRequest_UrlInfo::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientMalwareRequest_UrlInfo*>( + &from)); +} + +void ClientMalwareRequest_UrlInfo::MergeFrom(const ClientMalwareRequest_UrlInfo& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientMalwareRequest.UrlInfo) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + ip_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.ip_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + if (cached_has_bits & 0x00000004u) { + _has_bits_[0] |= 0x00000004u; + method_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.method_); + } + if (cached_has_bits & 0x00000008u) { + _has_bits_[0] |= 0x00000008u; + referrer_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_); + } + if (cached_has_bits & 0x00000010u) { + resource_type_ = from.resource_type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + return true; +} + +void ClientMalwareRequest_UrlInfo::InternalSwap(ClientMalwareRequest_UrlInfo* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ip_.Swap(&other->ip_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + method_.Swap(&other->method_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + referrer_.Swap(&other->referrer_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(resource_type_, other->resource_type_); +} + +std::string ClientMalwareRequest_UrlInfo::GetTypeName() const { + return "safe_browsing.ClientMalwareRequest.UrlInfo"; +} + + +// =================================================================== + +void ClientMalwareRequest::InitAsDefaultInstance() { + ::safe_browsing::_ClientMalwareRequest_default_instance_._instance.get_mutable()->population_ = const_cast< ::safe_browsing::ChromeUserPopulation*>( + ::safe_browsing::ChromeUserPopulation::internal_default_instance()); +} +class ClientMalwareRequest::_Internal { + public: + using HasBits = decltype(std::declval<ClientMalwareRequest>()._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; + } +}; + +const ::safe_browsing::ChromeUserPopulation& +ClientMalwareRequest::_Internal::population(const ClientMalwareRequest* msg) { + return *msg->population_; +} +ClientMalwareRequest::ClientMalwareRequest() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientMalwareRequest) +} +ClientMalwareRequest::ClientMalwareRequest(const ClientMalwareRequest& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + bad_ip_url_info_(from.bad_ip_url_info_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_url()) { + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + referrer_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_referrer_url()) { + referrer_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_url_); + } + if (from._internal_has_population()) { + population_ = new ::safe_browsing::ChromeUserPopulation(*from.population_); + } else { + population_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientMalwareRequest) +} + +void ClientMalwareRequest::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientMalwareRequest_csd_2eproto.base); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + referrer_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + population_ = nullptr; +} + +ClientMalwareRequest::~ClientMalwareRequest() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientMalwareRequest) + SharedDtor(); +} + +void ClientMalwareRequest::SharedDtor() { + url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + referrer_url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete population_; +} + +void ClientMalwareRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientMalwareRequest& ClientMalwareRequest::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientMalwareRequest_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientMalwareRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientMalwareRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + bad_ip_url_info_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + referrer_url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(population_ != nullptr); + population_->Clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientMalwareRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string referrer_url = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_referrer_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_population(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientMalwareRequest::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientMalwareRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 int i = 0, + n = static_cast<unsigned int>(this->_internal_bad_ip_url_info_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, this->_internal_bad_ip_url_info(i), target, stream); + } + + // optional .safe_browsing.ChromeUserPopulation population = 9; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 9, _Internal::population(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 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->bad_ip_url_info_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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( + *population_); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientMalwareRequest::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientMalwareRequest*>( + &from)); +} + +void ClientMalwareRequest::MergeFrom(const ClientMalwareRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientMalwareRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + bad_ip_url_info_.MergeFrom(from.bad_ip_url_info_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + referrer_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_url_); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(from._internal_population()); + } + } +} + +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 ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(bad_ip_url_info_)) return false; + return true; +} + +void ClientMalwareRequest::InternalSwap(ClientMalwareRequest* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + bad_ip_url_info_.InternalSwap(&other->bad_ip_url_info_); + url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + referrer_url_.Swap(&other->referrer_url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(population_, other->population_); +} + +std::string ClientMalwareRequest::GetTypeName() const { + return "safe_browsing.ClientMalwareRequest"; +} + + +// =================================================================== + +void LoginReputationClientRequest_Frame_Form::InitAsDefaultInstance() { +} +class LoginReputationClientRequest_Frame_Form::_Internal { + public: + using HasBits = decltype(std::declval<LoginReputationClientRequest_Frame_Form>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.LoginReputationClientRequest.Frame.Form) +} +LoginReputationClientRequest_Frame_Form::LoginReputationClientRequest_Frame_Form(const LoginReputationClientRequest_Frame_Form& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + action_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_action_url()) { + action_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.action_url_); + } + has_password_field_ = from.has_password_field_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.LoginReputationClientRequest.Frame.Form) +} + +void LoginReputationClientRequest_Frame_Form::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_LoginReputationClientRequest_Frame_Form_csd_2eproto.base); + action_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + has_password_field_ = false; +} + +LoginReputationClientRequest_Frame_Form::~LoginReputationClientRequest_Frame_Form() { + // @@protoc_insertion_point(destructor:safe_browsing.LoginReputationClientRequest.Frame.Form) + SharedDtor(); +} + +void LoginReputationClientRequest_Frame_Form::SharedDtor() { + action_url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void LoginReputationClientRequest_Frame_Form::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const LoginReputationClientRequest_Frame_Form& LoginReputationClientRequest_Frame_Form::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_LoginReputationClientRequest_Frame_Form_csd_2eproto.base); + return *internal_default_instance(); +} + + +void LoginReputationClientRequest_Frame_Form::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.LoginReputationClientRequest.Frame.Form) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + action_url_.ClearNonDefaultToEmptyNoArena(); + } + has_password_field_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* LoginReputationClientRequest_Frame_Form::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string action_url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_action_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_has_password_field(&has_bits); + has_password_field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* LoginReputationClientRequest_Frame_Form::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.LoginReputationClientRequest.Frame.Form) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void LoginReputationClientRequest_Frame_Form::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const LoginReputationClientRequest_Frame_Form*>( + &from)); +} + +void LoginReputationClientRequest_Frame_Form::MergeFrom(const LoginReputationClientRequest_Frame_Form& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.LoginReputationClientRequest.Frame.Form) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + action_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.action_url_); + } + if (cached_has_bits & 0x00000002u) { + has_password_field_ = from.has_password_field_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + action_url_.Swap(&other->action_url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(has_password_field_, other->has_password_field_); +} + +std::string LoginReputationClientRequest_Frame_Form::GetTypeName() const { + return "safe_browsing.LoginReputationClientRequest.Frame.Form"; +} + + +// =================================================================== + +void LoginReputationClientRequest_Frame::InitAsDefaultInstance() { +} +class LoginReputationClientRequest_Frame::_Internal { + public: + using HasBits = decltype(std::declval<LoginReputationClientRequest_Frame>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.LoginReputationClientRequest.Frame) +} +LoginReputationClientRequest_Frame::LoginReputationClientRequest_Frame(const LoginReputationClientRequest_Frame& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + referrer_chain_(from.referrer_chain_), + forms_(from.forms_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_url()) { + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + ::memcpy(&frame_index_, &from.frame_index_, + static_cast<size_t>(reinterpret_cast<char*>(&has_password_field_) - + reinterpret_cast<char*>(&frame_index_)) + sizeof(has_password_field_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.LoginReputationClientRequest.Frame) +} + +void LoginReputationClientRequest_Frame::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_LoginReputationClientRequest_Frame_csd_2eproto.base); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&frame_index_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&has_password_field_) - + reinterpret_cast<char*>(&frame_index_)) + sizeof(has_password_field_)); +} + +LoginReputationClientRequest_Frame::~LoginReputationClientRequest_Frame() { + // @@protoc_insertion_point(destructor:safe_browsing.LoginReputationClientRequest.Frame) + SharedDtor(); +} + +void LoginReputationClientRequest_Frame::SharedDtor() { + url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void LoginReputationClientRequest_Frame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const LoginReputationClientRequest_Frame& LoginReputationClientRequest_Frame::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_LoginReputationClientRequest_Frame_csd_2eproto.base); + return *internal_default_instance(); +} + + +void LoginReputationClientRequest_Frame::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.LoginReputationClientRequest.Frame) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + referrer_chain_.Clear(); + forms_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x0000000eu) { + ::memset(&frame_index_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&has_password_field_) - + reinterpret_cast<char*>(&frame_index_)) + sizeof(has_password_field_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* LoginReputationClientRequest_Frame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional int32 frame_index = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_frame_index(&has_bits); + frame_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional int32 parent_frame_index = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_parent_frame_index(&has_bits); + parent_frame_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string url = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_has_password_field(&has_bits); + has_password_field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .safe_browsing.ReferrerChainEntry referrer_chain = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* LoginReputationClientRequest_Frame::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.LoginReputationClientRequest.Frame) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 frame_index = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_frame_index(), target); + } + + // optional int32 parent_frame_index = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_has_password_field(), target); + } + + // repeated .safe_browsing.ReferrerChainEntry referrer_chain = 5; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_referrer_chain_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, this->_internal_referrer_chain(i), target, stream); + } + + // repeated .safe_browsing.LoginReputationClientRequest.Frame.Form forms = 6; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_forms_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, this->_internal_forms(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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->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->forms_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_frame_index()); + } + + // optional int32 parent_frame_index = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + 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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void LoginReputationClientRequest_Frame::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const LoginReputationClientRequest_Frame*>( + &from)); +} + +void LoginReputationClientRequest_Frame::MergeFrom(const LoginReputationClientRequest_Frame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.LoginReputationClientRequest.Frame) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + referrer_chain_.MergeFrom(from.referrer_chain_); + forms_.MergeFrom(from.forms_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + if (cached_has_bits & 0x00000002u) { + frame_index_ = from.frame_index_; + } + if (cached_has_bits & 0x00000004u) { + parent_frame_index_ = from.parent_frame_index_; + } + if (cached_has_bits & 0x00000008u) { + has_password_field_ = from.has_password_field_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + referrer_chain_.InternalSwap(&other->referrer_chain_); + forms_.InternalSwap(&other->forms_); + url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(frame_index_, other->frame_index_); + swap(parent_frame_index_, other->parent_frame_index_); + swap(has_password_field_, other->has_password_field_); +} + +std::string LoginReputationClientRequest_Frame::GetTypeName() const { + return "safe_browsing.LoginReputationClientRequest.Frame"; +} + + +// =================================================================== + +void LoginReputationClientRequest_PasswordReuseEvent::InitAsDefaultInstance() { +} +class LoginReputationClientRequest_PasswordReuseEvent::_Internal { + public: + using HasBits = decltype(std::declval<LoginReputationClientRequest_PasswordReuseEvent>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent) +} +LoginReputationClientRequest_PasswordReuseEvent::LoginReputationClientRequest_PasswordReuseEvent(const LoginReputationClientRequest_PasswordReuseEvent& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + domains_matching_password_(from.domains_matching_password_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&frame_id_, &from.frame_id_, + static_cast<size_t>(reinterpret_cast<char*>(&sync_account_type_) - + reinterpret_cast<char*>(&frame_id_)) + sizeof(sync_account_type_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent) +} + +void LoginReputationClientRequest_PasswordReuseEvent::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_LoginReputationClientRequest_PasswordReuseEvent_csd_2eproto.base); + ::memset(&frame_id_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&sync_account_type_) - + reinterpret_cast<char*>(&frame_id_)) + sizeof(sync_account_type_)); +} + +LoginReputationClientRequest_PasswordReuseEvent::~LoginReputationClientRequest_PasswordReuseEvent() { + // @@protoc_insertion_point(destructor:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent) + SharedDtor(); +} + +void LoginReputationClientRequest_PasswordReuseEvent::SharedDtor() { +} + +void LoginReputationClientRequest_PasswordReuseEvent::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const LoginReputationClientRequest_PasswordReuseEvent& LoginReputationClientRequest_PasswordReuseEvent::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_LoginReputationClientRequest_PasswordReuseEvent_csd_2eproto.base); + return *internal_default_instance(); +} + + +void LoginReputationClientRequest_PasswordReuseEvent::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + domains_matching_password_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&frame_id_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&sync_account_type_) - + reinterpret_cast<char*>(&frame_id_)) + sizeof(sync_account_type_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* LoginReputationClientRequest_PasswordReuseEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated string domains_matching_password = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_domains_matching_password(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_frame_id(&has_bits); + frame_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool is_chrome_signin_password = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_is_chrome_signin_password(&has_bits); + is_chrome_signin_password_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* LoginReputationClientRequest_PasswordReuseEvent::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent) + ::PROTOBUF_NAMESPACE_ID::uint32 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 = _has_bits_[0]; + // optional int32 frame_id = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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(domains_matching_password_.size()); + for (int i = 0, n = domains_matching_password_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + domains_matching_password_.Get(i)); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional int32 frame_id = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + 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 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sync_account_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void LoginReputationClientRequest_PasswordReuseEvent::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const LoginReputationClientRequest_PasswordReuseEvent*>( + &from)); +} + +void LoginReputationClientRequest_PasswordReuseEvent::MergeFrom(const LoginReputationClientRequest_PasswordReuseEvent& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + domains_matching_password_.MergeFrom(from.domains_matching_password_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + frame_id_ = from.frame_id_; + } + if (cached_has_bits & 0x00000002u) { + is_chrome_signin_password_ = from.is_chrome_signin_password_; + } + if (cached_has_bits & 0x00000004u) { + sync_account_type_ = from.sync_account_type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + domains_matching_password_.InternalSwap(&other->domains_matching_password_); + swap(frame_id_, other->frame_id_); + swap(is_chrome_signin_password_, other->is_chrome_signin_password_); + swap(sync_account_type_, other->sync_account_type_); +} + +std::string LoginReputationClientRequest_PasswordReuseEvent::GetTypeName() const { + return "safe_browsing.LoginReputationClientRequest.PasswordReuseEvent"; +} + + +// =================================================================== + +void LoginReputationClientRequest::InitAsDefaultInstance() { + ::safe_browsing::_LoginReputationClientRequest_default_instance_._instance.get_mutable()->password_reuse_event_ = const_cast< ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent*>( + ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent::internal_default_instance()); + ::safe_browsing::_LoginReputationClientRequest_default_instance_._instance.get_mutable()->population_ = const_cast< ::safe_browsing::ChromeUserPopulation*>( + ::safe_browsing::ChromeUserPopulation::internal_default_instance()); +} +class LoginReputationClientRequest::_Internal { + public: + using HasBits = decltype(std::declval<LoginReputationClientRequest>()._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->password_reuse_event_; +} +const ::safe_browsing::ChromeUserPopulation& +LoginReputationClientRequest::_Internal::population(const LoginReputationClientRequest* msg) { + return *msg->population_; +} +LoginReputationClientRequest::LoginReputationClientRequest() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.LoginReputationClientRequest) +} +LoginReputationClientRequest::LoginReputationClientRequest(const LoginReputationClientRequest& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + frames_(from.frames_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + page_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_page_url()) { + page_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.page_url_); + } + if (from._internal_has_password_reuse_event()) { + password_reuse_event_ = new ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent(*from.password_reuse_event_); + } else { + password_reuse_event_ = nullptr; + } + if (from._internal_has_population()) { + population_ = new ::safe_browsing::ChromeUserPopulation(*from.population_); + } else { + population_ = nullptr; + } + ::memcpy(&trigger_type_, &from.trigger_type_, + static_cast<size_t>(reinterpret_cast<char*>(&clicked_through_interstitial_) - + reinterpret_cast<char*>(&trigger_type_)) + sizeof(clicked_through_interstitial_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.LoginReputationClientRequest) +} + +void LoginReputationClientRequest::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_LoginReputationClientRequest_csd_2eproto.base); + page_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&password_reuse_event_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&clicked_through_interstitial_) - + reinterpret_cast<char*>(&password_reuse_event_)) + sizeof(clicked_through_interstitial_)); +} + +LoginReputationClientRequest::~LoginReputationClientRequest() { + // @@protoc_insertion_point(destructor:safe_browsing.LoginReputationClientRequest) + SharedDtor(); +} + +void LoginReputationClientRequest::SharedDtor() { + page_url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete password_reuse_event_; + if (this != internal_default_instance()) delete population_; +} + +void LoginReputationClientRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const LoginReputationClientRequest& LoginReputationClientRequest::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_LoginReputationClientRequest_csd_2eproto.base); + return *internal_default_instance(); +} + + +void LoginReputationClientRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.LoginReputationClientRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + frames_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + page_url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(password_reuse_event_ != nullptr); + password_reuse_event_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(population_ != nullptr); + population_->Clear(); + } + } + if (cached_has_bits & 0x00000038u) { + ::memset(&trigger_type_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&clicked_through_interstitial_) - + reinterpret_cast<char*>(&trigger_type_)) + sizeof(clicked_through_interstitial_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* LoginReputationClientRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string page_url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_page_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_stored_verdict_cnt(&has_bits); + stored_verdict_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .safe_browsing.ChromeUserPopulation population = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + _Internal::set_has_clicked_through_interstitial(&has_bits); + clicked_through_interstitial_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* LoginReputationClientRequest::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.LoginReputationClientRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_trigger_type(), target); + } + + // repeated .safe_browsing.LoginReputationClientRequest.Frame frames = 3; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_frames_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_frames(i), target, stream); + } + + // optional .safe_browsing.LoginReputationClientRequest.PasswordReuseEvent password_reuse_event = 4; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::password_reuse_event(this), target, stream); + } + + // optional int32 stored_verdict_cnt = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_stored_verdict_cnt(), target); + } + + // optional .safe_browsing.ChromeUserPopulation population = 6; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::population(this), target, stream); + } + + // optional bool clicked_through_interstitial = 7; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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->frames_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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( + *password_reuse_event_); + } + + // optional .safe_browsing.ChromeUserPopulation population = 6; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *population_); + } + + // optional .safe_browsing.LoginReputationClientRequest.TriggerType trigger_type = 2; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_trigger_type()); + } + + // optional int32 stored_verdict_cnt = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + 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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void LoginReputationClientRequest::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const LoginReputationClientRequest*>( + &from)); +} + +void LoginReputationClientRequest::MergeFrom(const LoginReputationClientRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.LoginReputationClientRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + frames_.MergeFrom(from.frames_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + page_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.page_url_); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_password_reuse_event()->::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent::MergeFrom(from._internal_password_reuse_event()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(from._internal_population()); + } + if (cached_has_bits & 0x00000008u) { + trigger_type_ = from.trigger_type_; + } + if (cached_has_bits & 0x00000010u) { + stored_verdict_cnt_ = from.stored_verdict_cnt_; + } + if (cached_has_bits & 0x00000020u) { + clicked_through_interstitial_ = from.clicked_through_interstitial_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + frames_.InternalSwap(&other->frames_); + page_url_.Swap(&other->page_url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(password_reuse_event_, other->password_reuse_event_); + swap(population_, other->population_); + swap(trigger_type_, other->trigger_type_); + swap(stored_verdict_cnt_, other->stored_verdict_cnt_); + swap(clicked_through_interstitial_, other->clicked_through_interstitial_); +} + +std::string LoginReputationClientRequest::GetTypeName() const { + return "safe_browsing.LoginReputationClientRequest"; +} + + +// =================================================================== + +void LoginReputationClientResponse::InitAsDefaultInstance() { +} +class LoginReputationClientResponse::_Internal { + public: + using HasBits = decltype(std::declval<LoginReputationClientResponse>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.LoginReputationClientResponse) +} +LoginReputationClientResponse::LoginReputationClientResponse(const LoginReputationClientResponse& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + cache_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_cache_expression()) { + cache_expression_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cache_expression_); + } + verdict_token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_verdict_token()) { + verdict_token_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.verdict_token_); + } + ::memcpy(&cache_duration_sec_, &from.cache_duration_sec_, + static_cast<size_t>(reinterpret_cast<char*>(&deprecated_cache_expression_exact_match_) - + reinterpret_cast<char*>(&cache_duration_sec_)) + sizeof(deprecated_cache_expression_exact_match_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.LoginReputationClientResponse) +} + +void LoginReputationClientResponse::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_LoginReputationClientResponse_csd_2eproto.base); + cache_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + verdict_token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&cache_duration_sec_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&deprecated_cache_expression_exact_match_) - + reinterpret_cast<char*>(&cache_duration_sec_)) + sizeof(deprecated_cache_expression_exact_match_)); +} + +LoginReputationClientResponse::~LoginReputationClientResponse() { + // @@protoc_insertion_point(destructor:safe_browsing.LoginReputationClientResponse) + SharedDtor(); +} + +void LoginReputationClientResponse::SharedDtor() { + cache_expression_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + verdict_token_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void LoginReputationClientResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const LoginReputationClientResponse& LoginReputationClientResponse::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_LoginReputationClientResponse_csd_2eproto.base); + return *internal_default_instance(); +} + + +void LoginReputationClientResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.LoginReputationClientResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + cache_expression_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + verdict_token_.ClearNonDefaultToEmptyNoArena(); + } + } + if (cached_has_bits & 0x0000001cu) { + ::memset(&cache_duration_sec_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&deprecated_cache_expression_exact_match_) - + reinterpret_cast<char*>(&cache_duration_sec_)) + sizeof(deprecated_cache_expression_exact_match_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* LoginReputationClientResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional .safe_browsing.LoginReputationClientResponse.VerdictType verdict_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_cache_duration_sec(&has_bits); + cache_duration_sec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string cache_expression = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_cache_expression(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_deprecated_cache_expression_exact_match(&has_bits); + deprecated_cache_expression_exact_match_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes verdict_token = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + auto str = _internal_mutable_verdict_token(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* LoginReputationClientResponse::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.LoginReputationClientResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .safe_browsing.LoginReputationClientResponse.VerdictType verdict_type = 1; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_verdict_type(), target); + } + + // optional int64 cache_duration_sec = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_cache_duration_sec()); + } + + // optional .safe_browsing.LoginReputationClientResponse.VerdictType verdict_type = 1; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void LoginReputationClientResponse::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const LoginReputationClientResponse*>( + &from)); +} + +void LoginReputationClientResponse::MergeFrom(const LoginReputationClientResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.LoginReputationClientResponse) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + cache_expression_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cache_expression_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + verdict_token_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.verdict_token_); + } + if (cached_has_bits & 0x00000004u) { + cache_duration_sec_ = from.cache_duration_sec_; + } + if (cached_has_bits & 0x00000008u) { + verdict_type_ = from.verdict_type_; + } + if (cached_has_bits & 0x00000010u) { + deprecated_cache_expression_exact_match_ = from.deprecated_cache_expression_exact_match_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + cache_expression_.Swap(&other->cache_expression_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + verdict_token_.Swap(&other->verdict_token_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(cache_duration_sec_, other->cache_duration_sec_); + swap(verdict_type_, other->verdict_type_); + swap(deprecated_cache_expression_exact_match_, other->deprecated_cache_expression_exact_match_); +} + +std::string LoginReputationClientResponse::GetTypeName() const { + return "safe_browsing.LoginReputationClientResponse"; +} + + +// =================================================================== + +void ClientMalwareResponse::InitAsDefaultInstance() { +} +class ClientMalwareResponse::_Internal { + public: + using HasBits = decltype(std::declval<ClientMalwareResponse>()._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; + } +}; + +ClientMalwareResponse::ClientMalwareResponse() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientMalwareResponse) +} +ClientMalwareResponse::ClientMalwareResponse(const ClientMalwareResponse& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + bad_ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_bad_ip()) { + bad_ip_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bad_ip_); + } + bad_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_bad_url()) { + bad_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bad_url_); + } + blacklist_ = from.blacklist_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientMalwareResponse) +} + +void ClientMalwareResponse::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientMalwareResponse_csd_2eproto.base); + bad_ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + bad_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + blacklist_ = false; +} + +ClientMalwareResponse::~ClientMalwareResponse() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientMalwareResponse) + SharedDtor(); +} + +void ClientMalwareResponse::SharedDtor() { + bad_ip_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + bad_url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientMalwareResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientMalwareResponse& ClientMalwareResponse::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientMalwareResponse_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientMalwareResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientMalwareResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + bad_ip_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + bad_url_.ClearNonDefaultToEmptyNoArena(); + } + } + blacklist_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientMalwareResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required bool blacklist = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_blacklist(&has_bits); + blacklist_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string bad_ip = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_bad_ip(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string bad_url = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_bad_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientMalwareResponse::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientMalwareResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required bool blacklist = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientMalwareResponse::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientMalwareResponse*>( + &from)); +} + +void ClientMalwareResponse::MergeFrom(const ClientMalwareResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientMalwareResponse) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + bad_ip_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bad_ip_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + bad_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bad_url_); + } + if (cached_has_bits & 0x00000004u) { + blacklist_ = from.blacklist_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 ((_has_bits_[0] & 0x00000004) != 0x00000004) return false; + return true; +} + +void ClientMalwareResponse::InternalSwap(ClientMalwareResponse* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + bad_ip_.Swap(&other->bad_ip_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + bad_url_.Swap(&other->bad_url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(blacklist_, other->blacklist_); +} + +std::string ClientMalwareResponse::GetTypeName() const { + return "safe_browsing.ClientMalwareResponse"; +} + + +// =================================================================== + +void ClientDownloadRequest_Digests::InitAsDefaultInstance() { +} +class ClientDownloadRequest_Digests::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadRequest_Digests>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.Digests) +} +ClientDownloadRequest_Digests::ClientDownloadRequest_Digests(const ClientDownloadRequest_Digests& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + sha256_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_sha256()) { + sha256_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.sha256_); + } + sha1_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_sha1()) { + sha1_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.sha1_); + } + md5_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_md5()) { + md5_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.md5_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.Digests) +} + +void ClientDownloadRequest_Digests::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadRequest_Digests_csd_2eproto.base); + sha256_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + sha1_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + md5_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ClientDownloadRequest_Digests::~ClientDownloadRequest_Digests() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.Digests) + SharedDtor(); +} + +void ClientDownloadRequest_Digests::SharedDtor() { + sha256_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + sha1_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + md5_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientDownloadRequest_Digests::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadRequest_Digests& ClientDownloadRequest_Digests::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadRequest_Digests_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadRequest_Digests::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.Digests) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + sha256_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + sha1_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + md5_.ClearNonDefaultToEmptyNoArena(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadRequest_Digests::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional bytes sha256 = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_sha256(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes sha1 = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_sha1(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes md5 = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_md5(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadRequest_Digests::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.Digests) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadRequest_Digests::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadRequest_Digests*>( + &from)); +} + +void ClientDownloadRequest_Digests::MergeFrom(const ClientDownloadRequest_Digests& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.Digests) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + sha256_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.sha256_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + sha1_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.sha1_); + } + if (cached_has_bits & 0x00000004u) { + _has_bits_[0] |= 0x00000004u; + md5_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.md5_); + } + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + sha256_.Swap(&other->sha256_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + sha1_.Swap(&other->sha1_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + md5_.Swap(&other->md5_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string ClientDownloadRequest_Digests::GetTypeName() const { + return "safe_browsing.ClientDownloadRequest.Digests"; +} + + +// =================================================================== + +void ClientDownloadRequest_Resource::InitAsDefaultInstance() { +} +class ClientDownloadRequest_Resource::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadRequest_Resource>()._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; + } +}; + +ClientDownloadRequest_Resource::ClientDownloadRequest_Resource() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.Resource) +} +ClientDownloadRequest_Resource::ClientDownloadRequest_Resource(const ClientDownloadRequest_Resource& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_url()) { + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + remote_ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_remote_ip()) { + remote_ip_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.remote_ip_); + } + referrer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_referrer()) { + referrer_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_); + } + type_ = from.type_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.Resource) +} + +void ClientDownloadRequest_Resource::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadRequest_Resource_csd_2eproto.base); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + remote_ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + referrer_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + type_ = 0; +} + +ClientDownloadRequest_Resource::~ClientDownloadRequest_Resource() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.Resource) + SharedDtor(); +} + +void ClientDownloadRequest_Resource::SharedDtor() { + url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + remote_ip_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + referrer_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientDownloadRequest_Resource::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadRequest_Resource& ClientDownloadRequest_Resource::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadRequest_Resource_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadRequest_Resource::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.Resource) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + remote_ip_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + referrer_.ClearNonDefaultToEmptyNoArena(); + } + } + type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadRequest_Resource::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_remote_ip(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string referrer = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_referrer(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadRequest_Resource::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.Resource) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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 + + ::PROTOBUF_NAMESPACE_ID::internal::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 (((_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 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadRequest_Resource::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadRequest_Resource*>( + &from)); +} + +void ClientDownloadRequest_Resource::MergeFrom(const ClientDownloadRequest_Resource& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.Resource) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + remote_ip_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.remote_ip_); + } + if (cached_has_bits & 0x00000004u) { + _has_bits_[0] |= 0x00000004u; + referrer_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_); + } + if (cached_has_bits & 0x00000008u) { + type_ = from.type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 ((_has_bits_[0] & 0x00000009) != 0x00000009) return false; + return true; +} + +void ClientDownloadRequest_Resource::InternalSwap(ClientDownloadRequest_Resource* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + remote_ip_.Swap(&other->remote_ip_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + referrer_.Swap(&other->referrer_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(type_, other->type_); +} + +std::string ClientDownloadRequest_Resource::GetTypeName() const { + return "safe_browsing.ClientDownloadRequest.Resource"; +} + + +// =================================================================== + +void ClientDownloadRequest_CertificateChain_Element::InitAsDefaultInstance() { +} +class ClientDownloadRequest_CertificateChain_Element::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadRequest_CertificateChain_Element>()._has_bits_); + static void set_has_certificate(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ClientDownloadRequest_CertificateChain_Element::ClientDownloadRequest_CertificateChain_Element() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.CertificateChain.Element) +} +ClientDownloadRequest_CertificateChain_Element::ClientDownloadRequest_CertificateChain_Element(const ClientDownloadRequest_CertificateChain_Element& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + certificate_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_certificate()) { + certificate_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.certificate_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.CertificateChain.Element) +} + +void ClientDownloadRequest_CertificateChain_Element::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadRequest_CertificateChain_Element_csd_2eproto.base); + certificate_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ClientDownloadRequest_CertificateChain_Element::~ClientDownloadRequest_CertificateChain_Element() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.CertificateChain.Element) + SharedDtor(); +} + +void ClientDownloadRequest_CertificateChain_Element::SharedDtor() { + certificate_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientDownloadRequest_CertificateChain_Element::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadRequest_CertificateChain_Element& ClientDownloadRequest_CertificateChain_Element::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadRequest_CertificateChain_Element_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadRequest_CertificateChain_Element::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.CertificateChain.Element) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + certificate_.ClearNonDefaultToEmptyNoArena(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadRequest_CertificateChain_Element::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional bytes certificate = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_certificate(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadRequest_CertificateChain_Element::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.CertificateChain.Element) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bytes certificate = 1; + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadRequest_CertificateChain_Element::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadRequest_CertificateChain_Element*>( + &from)); +} + +void ClientDownloadRequest_CertificateChain_Element::MergeFrom(const ClientDownloadRequest_CertificateChain_Element& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.CertificateChain.Element) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_certificate()) { + _has_bits_[0] |= 0x00000001u; + certificate_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.certificate_); + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + certificate_.Swap(&other->certificate_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string ClientDownloadRequest_CertificateChain_Element::GetTypeName() const { + return "safe_browsing.ClientDownloadRequest.CertificateChain.Element"; +} + + +// =================================================================== + +void ClientDownloadRequest_CertificateChain::InitAsDefaultInstance() { +} +class ClientDownloadRequest_CertificateChain::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadRequest_CertificateChain>()._has_bits_); +}; + +ClientDownloadRequest_CertificateChain::ClientDownloadRequest_CertificateChain() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.CertificateChain) +} +ClientDownloadRequest_CertificateChain::ClientDownloadRequest_CertificateChain(const ClientDownloadRequest_CertificateChain& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + element_(from.element_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.CertificateChain) +} + +void ClientDownloadRequest_CertificateChain::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadRequest_CertificateChain_csd_2eproto.base); +} + +ClientDownloadRequest_CertificateChain::~ClientDownloadRequest_CertificateChain() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.CertificateChain) + SharedDtor(); +} + +void ClientDownloadRequest_CertificateChain::SharedDtor() { +} + +void ClientDownloadRequest_CertificateChain::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadRequest_CertificateChain& ClientDownloadRequest_CertificateChain::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadRequest_CertificateChain_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadRequest_CertificateChain::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.CertificateChain) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + element_.Clear(); + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadRequest_CertificateChain::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated .safe_browsing.ClientDownloadRequest.CertificateChain.Element element = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadRequest_CertificateChain::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.CertificateChain) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .safe_browsing.ClientDownloadRequest.CertificateChain.Element element = 1; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_element_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_element(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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->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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadRequest_CertificateChain::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadRequest_CertificateChain*>( + &from)); +} + +void ClientDownloadRequest_CertificateChain::MergeFrom(const ClientDownloadRequest_CertificateChain& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.CertificateChain) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + element_.MergeFrom(from.element_); +} + +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_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + element_.InternalSwap(&other->element_); +} + +std::string ClientDownloadRequest_CertificateChain::GetTypeName() const { + return "safe_browsing.ClientDownloadRequest.CertificateChain"; +} + + +// =================================================================== + +void ClientDownloadRequest_ExtendedAttr::InitAsDefaultInstance() { +} +class ClientDownloadRequest_ExtendedAttr::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadRequest_ExtendedAttr>()._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; + } +}; + +ClientDownloadRequest_ExtendedAttr::ClientDownloadRequest_ExtendedAttr() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.ExtendedAttr) +} +ClientDownloadRequest_ExtendedAttr::ClientDownloadRequest_ExtendedAttr(const ClientDownloadRequest_ExtendedAttr& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_key()) { + key_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.key_); + } + value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_value()) { + value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.ExtendedAttr) +} + +void ClientDownloadRequest_ExtendedAttr::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadRequest_ExtendedAttr_csd_2eproto.base); + key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ClientDownloadRequest_ExtendedAttr::~ClientDownloadRequest_ExtendedAttr() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.ExtendedAttr) + SharedDtor(); +} + +void ClientDownloadRequest_ExtendedAttr::SharedDtor() { + key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientDownloadRequest_ExtendedAttr::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadRequest_ExtendedAttr& ClientDownloadRequest_ExtendedAttr::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadRequest_ExtendedAttr_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadRequest_ExtendedAttr::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.ExtendedAttr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + key_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + value_.ClearNonDefaultToEmptyNoArena(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadRequest_ExtendedAttr::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required string key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_key(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_value(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadRequest_ExtendedAttr::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.ExtendedAttr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bytes value = 2; + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadRequest_ExtendedAttr::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadRequest_ExtendedAttr*>( + &from)); +} + +void ClientDownloadRequest_ExtendedAttr::MergeFrom(const ClientDownloadRequest_ExtendedAttr& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.ExtendedAttr) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + key_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.key_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_); + } + } +} + +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 ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + return true; +} + +void ClientDownloadRequest_ExtendedAttr::InternalSwap(ClientDownloadRequest_ExtendedAttr* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string ClientDownloadRequest_ExtendedAttr::GetTypeName() const { + return "safe_browsing.ClientDownloadRequest.ExtendedAttr"; +} + + +// =================================================================== + +void ClientDownloadRequest_SignatureInfo::InitAsDefaultInstance() { +} +class ClientDownloadRequest_SignatureInfo::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadRequest_SignatureInfo>()._has_bits_); + static void set_has_trusted(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ClientDownloadRequest_SignatureInfo::ClientDownloadRequest_SignatureInfo() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.SignatureInfo) +} +ClientDownloadRequest_SignatureInfo::ClientDownloadRequest_SignatureInfo(const ClientDownloadRequest_SignatureInfo& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + certificate_chain_(from.certificate_chain_), + signed_data_(from.signed_data_), + xattr_(from.xattr_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + trusted_ = from.trusted_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.SignatureInfo) +} + +void ClientDownloadRequest_SignatureInfo::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadRequest_SignatureInfo_csd_2eproto.base); + trusted_ = false; +} + +ClientDownloadRequest_SignatureInfo::~ClientDownloadRequest_SignatureInfo() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.SignatureInfo) + SharedDtor(); +} + +void ClientDownloadRequest_SignatureInfo::SharedDtor() { +} + +void ClientDownloadRequest_SignatureInfo::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadRequest_SignatureInfo& ClientDownloadRequest_SignatureInfo::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadRequest_SignatureInfo_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadRequest_SignatureInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.SignatureInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + certificate_chain_.Clear(); + signed_data_.Clear(); + xattr_.Clear(); + trusted_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadRequest_SignatureInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_trusted(&has_bits); + trusted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated bytes signed_data = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_signed_data(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadRequest_SignatureInfo::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.SignatureInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_certificate_chain_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_certificate_chain(i), target, stream); + } + + cached_has_bits = _has_bits_[0]; + // optional bool trusted = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 int i = 0, + n = static_cast<unsigned int>(this->_internal_xattr_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, this->_internal_xattr(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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->certificate_chain_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated bytes signed_data = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(signed_data_.size()); + for (int i = 0, n = signed_data_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + signed_data_.Get(i)); + } + + // repeated .safe_browsing.ClientDownloadRequest.ExtendedAttr xattr = 4; + total_size += 1UL * this->_internal_xattr_size(); + for (const auto& msg : this->xattr_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional bool trusted = 2; + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadRequest_SignatureInfo::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadRequest_SignatureInfo*>( + &from)); +} + +void ClientDownloadRequest_SignatureInfo::MergeFrom(const ClientDownloadRequest_SignatureInfo& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.SignatureInfo) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + certificate_chain_.MergeFrom(from.certificate_chain_); + signed_data_.MergeFrom(from.signed_data_); + xattr_.MergeFrom(from.xattr_); + if (from._internal_has_trusted()) { + _internal_set_trusted(from._internal_trusted()); + } +} + +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(xattr_)) return false; + return true; +} + +void ClientDownloadRequest_SignatureInfo::InternalSwap(ClientDownloadRequest_SignatureInfo* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + certificate_chain_.InternalSwap(&other->certificate_chain_); + signed_data_.InternalSwap(&other->signed_data_); + xattr_.InternalSwap(&other->xattr_); + swap(trusted_, other->trusted_); +} + +std::string ClientDownloadRequest_SignatureInfo::GetTypeName() const { + return "safe_browsing.ClientDownloadRequest.SignatureInfo"; +} + + +// =================================================================== + +void ClientDownloadRequest_PEImageHeaders_DebugData::InitAsDefaultInstance() { +} +class ClientDownloadRequest_PEImageHeaders_DebugData::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadRequest_PEImageHeaders_DebugData>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData) +} +ClientDownloadRequest_PEImageHeaders_DebugData::ClientDownloadRequest_PEImageHeaders_DebugData(const ClientDownloadRequest_PEImageHeaders_DebugData& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + directory_entry_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_directory_entry()) { + directory_entry_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.directory_entry_); + } + raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_raw_data()) { + raw_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.raw_data_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData) +} + +void ClientDownloadRequest_PEImageHeaders_DebugData::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadRequest_PEImageHeaders_DebugData_csd_2eproto.base); + directory_entry_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ClientDownloadRequest_PEImageHeaders_DebugData::~ClientDownloadRequest_PEImageHeaders_DebugData() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData) + SharedDtor(); +} + +void ClientDownloadRequest_PEImageHeaders_DebugData::SharedDtor() { + directory_entry_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + raw_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientDownloadRequest_PEImageHeaders_DebugData::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadRequest_PEImageHeaders_DebugData& ClientDownloadRequest_PEImageHeaders_DebugData::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadRequest_PEImageHeaders_DebugData_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadRequest_PEImageHeaders_DebugData::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + directory_entry_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + raw_data_.ClearNonDefaultToEmptyNoArena(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadRequest_PEImageHeaders_DebugData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional bytes directory_entry = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_directory_entry(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes raw_data = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_raw_data(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadRequest_PEImageHeaders_DebugData::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadRequest_PEImageHeaders_DebugData::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadRequest_PEImageHeaders_DebugData*>( + &from)); +} + +void ClientDownloadRequest_PEImageHeaders_DebugData::MergeFrom(const ClientDownloadRequest_PEImageHeaders_DebugData& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + directory_entry_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.directory_entry_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + raw_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.raw_data_); + } + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + directory_entry_.Swap(&other->directory_entry_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + raw_data_.Swap(&other->raw_data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string ClientDownloadRequest_PEImageHeaders_DebugData::GetTypeName() const { + return "safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData"; +} + + +// =================================================================== + +void ClientDownloadRequest_PEImageHeaders::InitAsDefaultInstance() { +} +class ClientDownloadRequest_PEImageHeaders::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadRequest_PEImageHeaders>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.PEImageHeaders) +} +ClientDownloadRequest_PEImageHeaders::ClientDownloadRequest_PEImageHeaders(const ClientDownloadRequest_PEImageHeaders& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + section_header_(from.section_header_), + debug_data_(from.debug_data_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + dos_header_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_dos_header()) { + dos_header_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dos_header_); + } + file_header_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_file_header()) { + file_header_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.file_header_); + } + optional_headers32_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_optional_headers32()) { + optional_headers32_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.optional_headers32_); + } + optional_headers64_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_optional_headers64()) { + optional_headers64_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.optional_headers64_); + } + export_section_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_export_section_data()) { + export_section_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.export_section_data_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.PEImageHeaders) +} + +void ClientDownloadRequest_PEImageHeaders::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadRequest_PEImageHeaders_csd_2eproto.base); + dos_header_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + file_header_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + optional_headers32_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + optional_headers64_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + export_section_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ClientDownloadRequest_PEImageHeaders::~ClientDownloadRequest_PEImageHeaders() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.PEImageHeaders) + SharedDtor(); +} + +void ClientDownloadRequest_PEImageHeaders::SharedDtor() { + dos_header_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + file_header_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + optional_headers32_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + optional_headers64_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + export_section_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientDownloadRequest_PEImageHeaders::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadRequest_PEImageHeaders& ClientDownloadRequest_PEImageHeaders::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadRequest_PEImageHeaders_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadRequest_PEImageHeaders::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.PEImageHeaders) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + section_header_.Clear(); + debug_data_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + dos_header_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + file_header_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + optional_headers32_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000008u) { + optional_headers64_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000010u) { + export_section_data_.ClearNonDefaultToEmptyNoArena(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadRequest_PEImageHeaders::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional bytes dos_header = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_dos_header(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes file_header = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_file_header(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes optional_headers32 = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_optional_headers32(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes optional_headers64 = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_optional_headers64(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated bytes section_header = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_section_header(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + auto str = _internal_mutable_export_section_data(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadRequest_PEImageHeaders::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.PEImageHeaders) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 int i = 0, + n = static_cast<unsigned int>(this->_internal_debug_data_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(7, this->_internal_debug_data(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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(section_header_.size()); + for (int i = 0, n = section_header_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + 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->debug_data_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadRequest_PEImageHeaders::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadRequest_PEImageHeaders*>( + &from)); +} + +void ClientDownloadRequest_PEImageHeaders::MergeFrom(const ClientDownloadRequest_PEImageHeaders& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.PEImageHeaders) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + section_header_.MergeFrom(from.section_header_); + debug_data_.MergeFrom(from.debug_data_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + dos_header_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dos_header_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + file_header_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.file_header_); + } + if (cached_has_bits & 0x00000004u) { + _has_bits_[0] |= 0x00000004u; + optional_headers32_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.optional_headers32_); + } + if (cached_has_bits & 0x00000008u) { + _has_bits_[0] |= 0x00000008u; + optional_headers64_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.optional_headers64_); + } + if (cached_has_bits & 0x00000010u) { + _has_bits_[0] |= 0x00000010u; + export_section_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.export_section_data_); + } + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + section_header_.InternalSwap(&other->section_header_); + debug_data_.InternalSwap(&other->debug_data_); + dos_header_.Swap(&other->dos_header_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + file_header_.Swap(&other->file_header_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + optional_headers32_.Swap(&other->optional_headers32_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + optional_headers64_.Swap(&other->optional_headers64_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + export_section_data_.Swap(&other->export_section_data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string ClientDownloadRequest_PEImageHeaders::GetTypeName() const { + return "safe_browsing.ClientDownloadRequest.PEImageHeaders"; +} + + +// =================================================================== + +void ClientDownloadRequest_MachOHeaders_LoadCommand::InitAsDefaultInstance() { +} +class ClientDownloadRequest_MachOHeaders_LoadCommand::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadRequest_MachOHeaders_LoadCommand>()._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; + } +}; + +ClientDownloadRequest_MachOHeaders_LoadCommand::ClientDownloadRequest_MachOHeaders_LoadCommand() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand) +} +ClientDownloadRequest_MachOHeaders_LoadCommand::ClientDownloadRequest_MachOHeaders_LoadCommand(const ClientDownloadRequest_MachOHeaders_LoadCommand& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + command_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_command()) { + command_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.command_); + } + command_id_ = from.command_id_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand) +} + +void ClientDownloadRequest_MachOHeaders_LoadCommand::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadRequest_MachOHeaders_LoadCommand_csd_2eproto.base); + command_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + command_id_ = 0u; +} + +ClientDownloadRequest_MachOHeaders_LoadCommand::~ClientDownloadRequest_MachOHeaders_LoadCommand() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand) + SharedDtor(); +} + +void ClientDownloadRequest_MachOHeaders_LoadCommand::SharedDtor() { + command_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientDownloadRequest_MachOHeaders_LoadCommand::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadRequest_MachOHeaders_LoadCommand& ClientDownloadRequest_MachOHeaders_LoadCommand::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadRequest_MachOHeaders_LoadCommand_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadRequest_MachOHeaders_LoadCommand::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + command_.ClearNonDefaultToEmptyNoArena(); + } + command_id_ = 0u; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadRequest_MachOHeaders_LoadCommand::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required uint32 command_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_command_id(&has_bits); + command_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // required bytes command = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_command(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadRequest_MachOHeaders_LoadCommand::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required uint32 command_id = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + 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 (((_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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_command_id()); + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + ::PROTOBUF_NAMESPACE_ID::uint32 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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadRequest_MachOHeaders_LoadCommand::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadRequest_MachOHeaders_LoadCommand*>( + &from)); +} + +void ClientDownloadRequest_MachOHeaders_LoadCommand::MergeFrom(const ClientDownloadRequest_MachOHeaders_LoadCommand& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + command_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.command_); + } + if (cached_has_bits & 0x00000002u) { + command_id_ = from.command_id_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + return true; +} + +void ClientDownloadRequest_MachOHeaders_LoadCommand::InternalSwap(ClientDownloadRequest_MachOHeaders_LoadCommand* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + command_.Swap(&other->command_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(command_id_, other->command_id_); +} + +std::string ClientDownloadRequest_MachOHeaders_LoadCommand::GetTypeName() const { + return "safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand"; +} + + +// =================================================================== + +void ClientDownloadRequest_MachOHeaders::InitAsDefaultInstance() { +} +class ClientDownloadRequest_MachOHeaders::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadRequest_MachOHeaders>()._has_bits_); + static void set_has_mach_header(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ClientDownloadRequest_MachOHeaders::ClientDownloadRequest_MachOHeaders() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.MachOHeaders) +} +ClientDownloadRequest_MachOHeaders::ClientDownloadRequest_MachOHeaders(const ClientDownloadRequest_MachOHeaders& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + load_commands_(from.load_commands_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + mach_header_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_mach_header()) { + mach_header_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.mach_header_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.MachOHeaders) +} + +void ClientDownloadRequest_MachOHeaders::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadRequest_MachOHeaders_csd_2eproto.base); + mach_header_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ClientDownloadRequest_MachOHeaders::~ClientDownloadRequest_MachOHeaders() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.MachOHeaders) + SharedDtor(); +} + +void ClientDownloadRequest_MachOHeaders::SharedDtor() { + mach_header_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientDownloadRequest_MachOHeaders::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadRequest_MachOHeaders& ClientDownloadRequest_MachOHeaders::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadRequest_MachOHeaders_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadRequest_MachOHeaders::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.MachOHeaders) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + load_commands_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + mach_header_.ClearNonDefaultToEmptyNoArena(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadRequest_MachOHeaders::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required bytes mach_header = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_mach_header(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadRequest_MachOHeaders::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.MachOHeaders) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 int i = 0, + n = static_cast<unsigned int>(this->_internal_load_commands_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_load_commands(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 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->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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadRequest_MachOHeaders::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadRequest_MachOHeaders*>( + &from)); +} + +void ClientDownloadRequest_MachOHeaders::MergeFrom(const ClientDownloadRequest_MachOHeaders& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.MachOHeaders) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + load_commands_.MergeFrom(from.load_commands_); + if (from._internal_has_mach_header()) { + _has_bits_[0] |= 0x00000001u; + mach_header_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.mach_header_); + } +} + +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 ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(load_commands_)) return false; + return true; +} + +void ClientDownloadRequest_MachOHeaders::InternalSwap(ClientDownloadRequest_MachOHeaders* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + load_commands_.InternalSwap(&other->load_commands_); + mach_header_.Swap(&other->mach_header_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string ClientDownloadRequest_MachOHeaders::GetTypeName() const { + return "safe_browsing.ClientDownloadRequest.MachOHeaders"; +} + + +// =================================================================== + +void ClientDownloadRequest_ImageHeaders::InitAsDefaultInstance() { + ::safe_browsing::_ClientDownloadRequest_ImageHeaders_default_instance_._instance.get_mutable()->pe_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_PEImageHeaders*>( + ::safe_browsing::ClientDownloadRequest_PEImageHeaders::internal_default_instance()); +} +class ClientDownloadRequest_ImageHeaders::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadRequest_ImageHeaders>()._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->pe_headers_; +} +ClientDownloadRequest_ImageHeaders::ClientDownloadRequest_ImageHeaders() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.ImageHeaders) +} +ClientDownloadRequest_ImageHeaders::ClientDownloadRequest_ImageHeaders(const ClientDownloadRequest_ImageHeaders& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + mach_o_headers_(from.mach_o_headers_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_pe_headers()) { + pe_headers_ = new ::safe_browsing::ClientDownloadRequest_PEImageHeaders(*from.pe_headers_); + } else { + pe_headers_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.ImageHeaders) +} + +void ClientDownloadRequest_ImageHeaders::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadRequest_ImageHeaders_csd_2eproto.base); + pe_headers_ = nullptr; +} + +ClientDownloadRequest_ImageHeaders::~ClientDownloadRequest_ImageHeaders() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.ImageHeaders) + SharedDtor(); +} + +void ClientDownloadRequest_ImageHeaders::SharedDtor() { + if (this != internal_default_instance()) delete pe_headers_; +} + +void ClientDownloadRequest_ImageHeaders::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadRequest_ImageHeaders& ClientDownloadRequest_ImageHeaders::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadRequest_ImageHeaders_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadRequest_ImageHeaders::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.ImageHeaders) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + mach_o_headers_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(pe_headers_ != nullptr); + pe_headers_->Clear(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadRequest_ImageHeaders::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadRequest_ImageHeaders::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.ImageHeaders) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::pe_headers(this), target, stream); + } + + // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders mach_o_headers = 2; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_mach_o_headers_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_mach_o_headers(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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->mach_o_headers_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *pe_headers_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadRequest_ImageHeaders::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadRequest_ImageHeaders*>( + &from)); +} + +void ClientDownloadRequest_ImageHeaders::MergeFrom(const ClientDownloadRequest_ImageHeaders& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.ImageHeaders) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + mach_o_headers_.MergeFrom(from.mach_o_headers_); + if (from._internal_has_pe_headers()) { + _internal_mutable_pe_headers()->::safe_browsing::ClientDownloadRequest_PEImageHeaders::MergeFrom(from._internal_pe_headers()); + } +} + +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(mach_o_headers_)) return false; + return true; +} + +void ClientDownloadRequest_ImageHeaders::InternalSwap(ClientDownloadRequest_ImageHeaders* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + mach_o_headers_.InternalSwap(&other->mach_o_headers_); + swap(pe_headers_, other->pe_headers_); +} + +std::string ClientDownloadRequest_ImageHeaders::GetTypeName() const { + return "safe_browsing.ClientDownloadRequest.ImageHeaders"; +} + + +// =================================================================== + +void ClientDownloadRequest_ArchivedBinary::InitAsDefaultInstance() { + ::safe_browsing::_ClientDownloadRequest_ArchivedBinary_default_instance_._instance.get_mutable()->digests_ = const_cast< ::safe_browsing::ClientDownloadRequest_Digests*>( + ::safe_browsing::ClientDownloadRequest_Digests::internal_default_instance()); + ::safe_browsing::_ClientDownloadRequest_ArchivedBinary_default_instance_._instance.get_mutable()->signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>( + ::safe_browsing::ClientDownloadRequest_SignatureInfo::internal_default_instance()); + ::safe_browsing::_ClientDownloadRequest_ArchivedBinary_default_instance_._instance.get_mutable()->image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>( + ::safe_browsing::ClientDownloadRequest_ImageHeaders::internal_default_instance()); +} +class ClientDownloadRequest_ArchivedBinary::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadRequest_ArchivedBinary>()._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->digests_; +} +const ::safe_browsing::ClientDownloadRequest_SignatureInfo& +ClientDownloadRequest_ArchivedBinary::_Internal::signature(const ClientDownloadRequest_ArchivedBinary* msg) { + return *msg->signature_; +} +const ::safe_browsing::ClientDownloadRequest_ImageHeaders& +ClientDownloadRequest_ArchivedBinary::_Internal::image_headers(const ClientDownloadRequest_ArchivedBinary* msg) { + return *msg->image_headers_; +} +ClientDownloadRequest_ArchivedBinary::ClientDownloadRequest_ArchivedBinary() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.ArchivedBinary) +} +ClientDownloadRequest_ArchivedBinary::ClientDownloadRequest_ArchivedBinary(const ClientDownloadRequest_ArchivedBinary& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + file_basename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_file_basename()) { + file_basename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.file_basename_); + } + if (from._internal_has_digests()) { + digests_ = new ::safe_browsing::ClientDownloadRequest_Digests(*from.digests_); + } else { + digests_ = nullptr; + } + if (from._internal_has_signature()) { + signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo(*from.signature_); + } else { + signature_ = nullptr; + } + if (from._internal_has_image_headers()) { + image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders(*from.image_headers_); + } else { + image_headers_ = nullptr; + } + ::memcpy(&length_, &from.length_, + static_cast<size_t>(reinterpret_cast<char*>(&download_type_) - + reinterpret_cast<char*>(&length_)) + sizeof(download_type_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.ArchivedBinary) +} + +void ClientDownloadRequest_ArchivedBinary::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadRequest_ArchivedBinary_csd_2eproto.base); + file_basename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&digests_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&download_type_) - + reinterpret_cast<char*>(&digests_)) + sizeof(download_type_)); +} + +ClientDownloadRequest_ArchivedBinary::~ClientDownloadRequest_ArchivedBinary() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.ArchivedBinary) + SharedDtor(); +} + +void ClientDownloadRequest_ArchivedBinary::SharedDtor() { + file_basename_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete digests_; + if (this != internal_default_instance()) delete signature_; + if (this != internal_default_instance()) delete image_headers_; +} + +void ClientDownloadRequest_ArchivedBinary::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadRequest_ArchivedBinary& ClientDownloadRequest_ArchivedBinary::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadRequest_ArchivedBinary_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadRequest_ArchivedBinary::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest.ArchivedBinary) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + file_basename_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(digests_ != nullptr); + digests_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(signature_ != nullptr); + signature_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(image_headers_ != nullptr); + image_headers_->Clear(); + } + } + if (cached_has_bits & 0x00000030u) { + ::memset(&length_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&download_type_) - + reinterpret_cast<char*>(&length_)) + sizeof(download_type_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadRequest_ArchivedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string file_basename = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_file_basename(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_length(&has_bits); + length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_image_headers(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadRequest_ArchivedBinary::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest.ArchivedBinary) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_download_type(), target); + } + + // optional .safe_browsing.ClientDownloadRequest.Digests digests = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::digests(this), target, stream); + } + + // optional int64 length = 4; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_length(), target); + } + + // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::signature(this), target, stream); + } + + // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::image_headers(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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( + *digests_); + } + + // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *signature_); + } + + // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *image_headers_); + } + + // optional int64 length = 4; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_length()); + } + + // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 2; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_download_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadRequest_ArchivedBinary::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadRequest_ArchivedBinary*>( + &from)); +} + +void ClientDownloadRequest_ArchivedBinary::MergeFrom(const ClientDownloadRequest_ArchivedBinary& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest.ArchivedBinary) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + file_basename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.file_basename_); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_digests()->::safe_browsing::ClientDownloadRequest_Digests::MergeFrom(from._internal_digests()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(from._internal_signature()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(from._internal_image_headers()); + } + if (cached_has_bits & 0x00000010u) { + length_ = from.length_; + } + if (cached_has_bits & 0x00000020u) { + download_type_ = from.download_type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 (!signature_->IsInitialized()) return false; + } + if (_internal_has_image_headers()) { + if (!image_headers_->IsInitialized()) return false; + } + return true; +} + +void ClientDownloadRequest_ArchivedBinary::InternalSwap(ClientDownloadRequest_ArchivedBinary* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + file_basename_.Swap(&other->file_basename_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(digests_, other->digests_); + swap(signature_, other->signature_); + swap(image_headers_, other->image_headers_); + swap(length_, other->length_); + swap(download_type_, other->download_type_); +} + +std::string ClientDownloadRequest_ArchivedBinary::GetTypeName() const { + return "safe_browsing.ClientDownloadRequest.ArchivedBinary"; +} + + +// =================================================================== + +void ClientDownloadRequest::InitAsDefaultInstance() { + ::safe_browsing::_ClientDownloadRequest_default_instance_._instance.get_mutable()->digests_ = const_cast< ::safe_browsing::ClientDownloadRequest_Digests*>( + ::safe_browsing::ClientDownloadRequest_Digests::internal_default_instance()); + ::safe_browsing::_ClientDownloadRequest_default_instance_._instance.get_mutable()->signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>( + ::safe_browsing::ClientDownloadRequest_SignatureInfo::internal_default_instance()); + ::safe_browsing::_ClientDownloadRequest_default_instance_._instance.get_mutable()->image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>( + ::safe_browsing::ClientDownloadRequest_ImageHeaders::internal_default_instance()); + ::safe_browsing::_ClientDownloadRequest_default_instance_._instance.get_mutable()->population_ = const_cast< ::safe_browsing::ChromeUserPopulation*>( + ::safe_browsing::ChromeUserPopulation::internal_default_instance()); +} +class ClientDownloadRequest::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadRequest>()._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] |= 2048u; + } + 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] |= 1024u; + } + 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] |= 4096u; + } + static void set_has_skipped_url_whitelist(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_skipped_certificate_whitelist(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_deprecated_download_attribution_finch_enabled(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_udif_code_signature(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +const ::safe_browsing::ClientDownloadRequest_Digests& +ClientDownloadRequest::_Internal::digests(const ClientDownloadRequest* msg) { + return *msg->digests_; +} +const ::safe_browsing::ClientDownloadRequest_SignatureInfo& +ClientDownloadRequest::_Internal::signature(const ClientDownloadRequest* msg) { + return *msg->signature_; +} +const ::safe_browsing::ClientDownloadRequest_ImageHeaders& +ClientDownloadRequest::_Internal::image_headers(const ClientDownloadRequest* msg) { + return *msg->image_headers_; +} +const ::safe_browsing::ChromeUserPopulation& +ClientDownloadRequest::_Internal::population(const ClientDownloadRequest* msg) { + return *msg->population_; +} +ClientDownloadRequest::ClientDownloadRequest() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest) +} +ClientDownloadRequest::ClientDownloadRequest(const ClientDownloadRequest& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + resources_(from.resources_), + archived_binary_(from.archived_binary_), + alternate_extensions_(from.alternate_extensions_), + referrer_chain_(from.referrer_chain_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_url()) { + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + file_basename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_file_basename()) { + file_basename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.file_basename_); + } + locale_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_locale()) { + locale_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.locale_); + } + udif_code_signature_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_udif_code_signature()) { + udif_code_signature_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.udif_code_signature_); + } + if (from._internal_has_digests()) { + digests_ = new ::safe_browsing::ClientDownloadRequest_Digests(*from.digests_); + } else { + digests_ = nullptr; + } + if (from._internal_has_signature()) { + signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo(*from.signature_); + } else { + signature_ = nullptr; + } + if (from._internal_has_image_headers()) { + image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders(*from.image_headers_); + } else { + image_headers_ = nullptr; + } + if (from._internal_has_population()) { + population_ = new ::safe_browsing::ChromeUserPopulation(*from.population_); + } else { + population_ = nullptr; + } + ::memcpy(&length_, &from.length_, + static_cast<size_t>(reinterpret_cast<char*>(&skipped_certificate_whitelist_) - + reinterpret_cast<char*>(&length_)) + sizeof(skipped_certificate_whitelist_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest) +} + +void ClientDownloadRequest::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadRequest_csd_2eproto.base); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + file_basename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + locale_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + udif_code_signature_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&digests_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&skipped_certificate_whitelist_) - + reinterpret_cast<char*>(&digests_)) + sizeof(skipped_certificate_whitelist_)); +} + +ClientDownloadRequest::~ClientDownloadRequest() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest) + SharedDtor(); +} + +void ClientDownloadRequest::SharedDtor() { + url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + file_basename_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + locale_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + udif_code_signature_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete digests_; + if (this != internal_default_instance()) delete signature_; + if (this != internal_default_instance()) delete image_headers_; + if (this != internal_default_instance()) delete population_; +} + +void ClientDownloadRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadRequest& ClientDownloadRequest::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadRequest_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + resources_.Clear(); + archived_binary_.Clear(); + alternate_extensions_.Clear(); + referrer_chain_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + file_basename_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + locale_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000008u) { + udif_code_signature_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(digests_ != nullptr); + digests_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(signature_ != nullptr); + signature_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(image_headers_ != nullptr); + image_headers_->Clear(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(population_ != nullptr); + population_->Clear(); + } + } + if (cached_has_bits & 0x00007f00u) { + ::memset(&length_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&skipped_certificate_whitelist_) - + reinterpret_cast<char*>(&length_)) + sizeof(skipped_certificate_whitelist_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_length(&has_bits); + length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + _Internal::set_has_user_initiated(&has_bits); + user_initiated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string file_basename = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + auto str = _internal_mutable_file_basename(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + auto str = _internal_mutable_locale(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 208)) { + _Internal::set_has_archive_valid(&has_bits); + archive_valid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool skipped_url_whitelist = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 224)) { + _Internal::set_has_skipped_url_whitelist(&has_bits); + skipped_url_whitelist_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool skipped_certificate_whitelist = 31; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 248)) { + _Internal::set_has_skipped_certificate_whitelist(&has_bits); + skipped_certificate_whitelist_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string alternate_extensions = 35; + case 35: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 2; + do { + ptr += 2; + auto str = _internal_add_alternate_extensions(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + _Internal::set_has_deprecated_download_attribution_finch_enabled(&has_bits); + deprecated_download_attribution_finch_enabled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes udif_code_signature = 40; + case 40: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + auto str = _internal_mutable_udif_code_signature(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadRequest::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::digests(this), target, stream); + } + + // required int64 length = 3; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_length(), target); + } + + // repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_resources_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, this->_internal_resources(i), target, stream); + } + + // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::signature(this), target, stream); + } + + // optional bool user_initiated = 6; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 18, _Internal::image_headers(this), target, stream); + } + + // repeated .safe_browsing.ClientDownloadRequest.ArchivedBinary archived_binary = 22; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_archived_binary_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(22, this->_internal_archived_binary(i), target, stream); + } + + // optional .safe_browsing.ChromeUserPopulation population = 24; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 24, _Internal::population(this), target, stream); + } + + // optional bool archive_valid = 26; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(26, this->_internal_archive_valid(), target); + } + + // optional bool skipped_url_whitelist = 28; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(28, this->_internal_skipped_url_whitelist(), target); + } + + // optional bool skipped_certificate_whitelist = 31; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 int i = 0, + n = static_cast<unsigned int>(this->_internal_referrer_chain_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(36, this->_internal_referrer_chain(i), target, stream); + } + + // optional bool DEPRECATED_download_attribution_finch_enabled = 39 [deprecated = true]; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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( + *digests_); + } + + if (_internal_has_length()) { + // required int64 length = 3; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + 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 (((_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( + *digests_); + + // required int64 length = 3; + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_length()); + + } else { + total_size += RequiredFieldsByteSizeFallback(); + } + ::PROTOBUF_NAMESPACE_ID::uint32 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->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->archived_binary_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated string alternate_extensions = 35; + total_size += 2 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(alternate_extensions_.size()); + for (int i = 0, n = alternate_extensions_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + alternate_extensions_.Get(i)); + } + + // repeated .safe_browsing.ReferrerChainEntry referrer_chain = 36; + total_size += 2UL * this->_internal_referrer_chain_size(); + for (const auto& msg : this->referrer_chain_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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( + *signature_); + } + + // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 18; + if (cached_has_bits & 0x00000040u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *image_headers_); + } + + // optional .safe_browsing.ChromeUserPopulation population = 24; + if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *population_); + } + + } + if (cached_has_bits & 0x00007e00u) { + // optional bool DEPRECATED_download_attribution_finch_enabled = 39 [deprecated = true]; + if (cached_has_bits & 0x00000200u) { + total_size += 2 + 1; + } + + // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 10 [default = WIN_EXECUTABLE]; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_download_type()); + } + + // optional bool user_initiated = 6; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + 1; + } + + // optional bool archive_valid = 26; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + 1; + } + + // optional bool skipped_url_whitelist = 28; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + 1; + } + + // optional bool skipped_certificate_whitelist = 31; + if (cached_has_bits & 0x00004000u) { + total_size += 2 + 1; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadRequest::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadRequest*>( + &from)); +} + +void ClientDownloadRequest::MergeFrom(const ClientDownloadRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + resources_.MergeFrom(from.resources_); + archived_binary_.MergeFrom(from.archived_binary_); + alternate_extensions_.MergeFrom(from.alternate_extensions_); + referrer_chain_.MergeFrom(from.referrer_chain_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + file_basename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.file_basename_); + } + if (cached_has_bits & 0x00000004u) { + _has_bits_[0] |= 0x00000004u; + locale_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.locale_); + } + if (cached_has_bits & 0x00000008u) { + _has_bits_[0] |= 0x00000008u; + udif_code_signature_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.udif_code_signature_); + } + if (cached_has_bits & 0x00000010u) { + _internal_mutable_digests()->::safe_browsing::ClientDownloadRequest_Digests::MergeFrom(from._internal_digests()); + } + if (cached_has_bits & 0x00000020u) { + _internal_mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(from._internal_signature()); + } + if (cached_has_bits & 0x00000040u) { + _internal_mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(from._internal_image_headers()); + } + if (cached_has_bits & 0x00000080u) { + _internal_mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(from._internal_population()); + } + } + if (cached_has_bits & 0x00007f00u) { + if (cached_has_bits & 0x00000100u) { + length_ = from.length_; + } + if (cached_has_bits & 0x00000200u) { + deprecated_download_attribution_finch_enabled_ = from.deprecated_download_attribution_finch_enabled_; + } + if (cached_has_bits & 0x00000400u) { + download_type_ = from.download_type_; + } + if (cached_has_bits & 0x00000800u) { + user_initiated_ = from.user_initiated_; + } + if (cached_has_bits & 0x00001000u) { + archive_valid_ = from.archive_valid_; + } + if (cached_has_bits & 0x00002000u) { + skipped_url_whitelist_ = from.skipped_url_whitelist_; + } + if (cached_has_bits & 0x00004000u) { + skipped_certificate_whitelist_ = from.skipped_certificate_whitelist_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 ((_has_bits_[0] & 0x00000111) != 0x00000111) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(resources_)) return false; + if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(archived_binary_)) return false; + if (_internal_has_signature()) { + if (!signature_->IsInitialized()) return false; + } + if (_internal_has_image_headers()) { + if (!image_headers_->IsInitialized()) return false; + } + return true; +} + +void ClientDownloadRequest::InternalSwap(ClientDownloadRequest* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + resources_.InternalSwap(&other->resources_); + archived_binary_.InternalSwap(&other->archived_binary_); + alternate_extensions_.InternalSwap(&other->alternate_extensions_); + referrer_chain_.InternalSwap(&other->referrer_chain_); + url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + file_basename_.Swap(&other->file_basename_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + locale_.Swap(&other->locale_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + udif_code_signature_.Swap(&other->udif_code_signature_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(digests_, other->digests_); + swap(signature_, other->signature_); + swap(image_headers_, other->image_headers_); + swap(population_, other->population_); + swap(length_, other->length_); + swap(deprecated_download_attribution_finch_enabled_, other->deprecated_download_attribution_finch_enabled_); + swap(download_type_, other->download_type_); + swap(user_initiated_, other->user_initiated_); + swap(archive_valid_, other->archive_valid_); + swap(skipped_url_whitelist_, other->skipped_url_whitelist_); + swap(skipped_certificate_whitelist_, other->skipped_certificate_whitelist_); +} + +std::string ClientDownloadRequest::GetTypeName() const { + return "safe_browsing.ClientDownloadRequest"; +} + + +// =================================================================== + +void ReferrerChainEntry_ServerRedirect::InitAsDefaultInstance() { +} +class ReferrerChainEntry_ServerRedirect::_Internal { + public: + using HasBits = decltype(std::declval<ReferrerChainEntry_ServerRedirect>()._has_bits_); + static void set_has_url(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ReferrerChainEntry_ServerRedirect::ReferrerChainEntry_ServerRedirect() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ReferrerChainEntry.ServerRedirect) +} +ReferrerChainEntry_ServerRedirect::ReferrerChainEntry_ServerRedirect(const ReferrerChainEntry_ServerRedirect& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_url()) { + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ReferrerChainEntry.ServerRedirect) +} + +void ReferrerChainEntry_ServerRedirect::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ReferrerChainEntry_ServerRedirect_csd_2eproto.base); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ReferrerChainEntry_ServerRedirect::~ReferrerChainEntry_ServerRedirect() { + // @@protoc_insertion_point(destructor:safe_browsing.ReferrerChainEntry.ServerRedirect) + SharedDtor(); +} + +void ReferrerChainEntry_ServerRedirect::SharedDtor() { + url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ReferrerChainEntry_ServerRedirect::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ReferrerChainEntry_ServerRedirect& ReferrerChainEntry_ServerRedirect::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ReferrerChainEntry_ServerRedirect_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ReferrerChainEntry_ServerRedirect::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ReferrerChainEntry.ServerRedirect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + url_.ClearNonDefaultToEmptyNoArena(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ReferrerChainEntry_ServerRedirect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReferrerChainEntry_ServerRedirect::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ReferrerChainEntry.ServerRedirect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string url = 1; + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReferrerChainEntry_ServerRedirect::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ReferrerChainEntry_ServerRedirect*>( + &from)); +} + +void ReferrerChainEntry_ServerRedirect::MergeFrom(const ReferrerChainEntry_ServerRedirect& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ReferrerChainEntry.ServerRedirect) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_url()) { + _has_bits_[0] |= 0x00000001u; + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string ReferrerChainEntry_ServerRedirect::GetTypeName() const { + return "safe_browsing.ReferrerChainEntry.ServerRedirect"; +} + + +// =================================================================== + +void ReferrerChainEntry::InitAsDefaultInstance() { +} +class ReferrerChainEntry::_Internal { + public: + using HasBits = decltype(std::declval<ReferrerChainEntry>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ReferrerChainEntry) +} +ReferrerChainEntry::ReferrerChainEntry(const ReferrerChainEntry& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + ip_addresses_(from.ip_addresses_), + server_redirect_chain_(from.server_redirect_chain_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_url()) { + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + referrer_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_referrer_url()) { + referrer_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_url_); + } + referrer_main_frame_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_referrer_main_frame_url()) { + referrer_main_frame_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_main_frame_url_); + } + main_frame_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_main_frame_url()) { + main_frame_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.main_frame_url_); + } + ::memcpy(&navigation_time_msec_, &from.navigation_time_msec_, + static_cast<size_t>(reinterpret_cast<char*>(&type_) - + reinterpret_cast<char*>(&navigation_time_msec_)) + sizeof(type_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ReferrerChainEntry) +} + +void ReferrerChainEntry::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ReferrerChainEntry_csd_2eproto.base); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + referrer_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + referrer_main_frame_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + main_frame_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&navigation_time_msec_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&is_retargeting_) - + reinterpret_cast<char*>(&navigation_time_msec_)) + sizeof(is_retargeting_)); + type_ = 4; +} + +ReferrerChainEntry::~ReferrerChainEntry() { + // @@protoc_insertion_point(destructor:safe_browsing.ReferrerChainEntry) + SharedDtor(); +} + +void ReferrerChainEntry::SharedDtor() { + url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + referrer_url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + referrer_main_frame_url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + main_frame_url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ReferrerChainEntry::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ReferrerChainEntry& ReferrerChainEntry::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ReferrerChainEntry_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ReferrerChainEntry::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ReferrerChainEntry) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ip_addresses_.Clear(); + server_redirect_chain_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + referrer_url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + referrer_main_frame_url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000008u) { + main_frame_url_.ClearNonDefaultToEmptyNoArena(); + } + } + if (cached_has_bits & 0x00000070u) { + ::memset(&navigation_time_msec_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&is_retargeting_) - + reinterpret_cast<char*>(&navigation_time_msec_)) + sizeof(is_retargeting_)); + type_ = 4; + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ReferrerChainEntry::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_ip_addresses(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_referrer_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + auto str = _internal_mutable_referrer_main_frame_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool is_retargeting = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + _Internal::set_has_is_retargeting(&has_bits); + is_retargeting_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional double navigation_time_msec = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 57)) { + _Internal::set_has_navigation_time_msec(&has_bits); + 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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + auto str = _internal_mutable_main_frame_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReferrerChainEntry::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ReferrerChainEntry) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_is_retargeting(), target); + } + + // optional double navigation_time_msec = 7; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(7, this->_internal_navigation_time_msec(), target); + } + + // repeated .safe_browsing.ReferrerChainEntry.ServerRedirect server_redirect_chain = 8; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_server_redirect_chain_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, this->_internal_server_redirect_chain(i), 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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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(ip_addresses_.size()); + for (int i = 0, n = ip_addresses_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + 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->server_redirect_chain_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReferrerChainEntry::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ReferrerChainEntry*>( + &from)); +} + +void ReferrerChainEntry::MergeFrom(const ReferrerChainEntry& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ReferrerChainEntry) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + ip_addresses_.MergeFrom(from.ip_addresses_); + server_redirect_chain_.MergeFrom(from.server_redirect_chain_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + referrer_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_url_); + } + if (cached_has_bits & 0x00000004u) { + _has_bits_[0] |= 0x00000004u; + referrer_main_frame_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_main_frame_url_); + } + if (cached_has_bits & 0x00000008u) { + _has_bits_[0] |= 0x00000008u; + main_frame_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.main_frame_url_); + } + if (cached_has_bits & 0x00000010u) { + navigation_time_msec_ = from.navigation_time_msec_; + } + if (cached_has_bits & 0x00000020u) { + is_retargeting_ = from.is_retargeting_; + } + if (cached_has_bits & 0x00000040u) { + type_ = from.type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ip_addresses_.InternalSwap(&other->ip_addresses_); + server_redirect_chain_.InternalSwap(&other->server_redirect_chain_); + url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + referrer_url_.Swap(&other->referrer_url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + referrer_main_frame_url_.Swap(&other->referrer_main_frame_url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + main_frame_url_.Swap(&other->main_frame_url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(navigation_time_msec_, other->navigation_time_msec_); + swap(is_retargeting_, other->is_retargeting_); + swap(type_, other->type_); +} + +std::string ReferrerChainEntry::GetTypeName() const { + return "safe_browsing.ReferrerChainEntry"; +} + + +// =================================================================== + +void ClientDownloadResponse_MoreInfo::InitAsDefaultInstance() { +} +class ClientDownloadResponse_MoreInfo::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadResponse_MoreInfo>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadResponse.MoreInfo) +} +ClientDownloadResponse_MoreInfo::ClientDownloadResponse_MoreInfo(const ClientDownloadResponse_MoreInfo& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + description_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_description()) { + description_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.description_); + } + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_url()) { + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadResponse.MoreInfo) +} + +void ClientDownloadResponse_MoreInfo::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadResponse_MoreInfo_csd_2eproto.base); + description_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ClientDownloadResponse_MoreInfo::~ClientDownloadResponse_MoreInfo() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadResponse.MoreInfo) + SharedDtor(); +} + +void ClientDownloadResponse_MoreInfo::SharedDtor() { + description_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientDownloadResponse_MoreInfo::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadResponse_MoreInfo& ClientDownloadResponse_MoreInfo::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadResponse_MoreInfo_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadResponse_MoreInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadResponse.MoreInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + description_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + url_.ClearNonDefaultToEmptyNoArena(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadResponse_MoreInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string description = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_description(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string url = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadResponse_MoreInfo::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadResponse.MoreInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadResponse_MoreInfo::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadResponse_MoreInfo*>( + &from)); +} + +void ClientDownloadResponse_MoreInfo::MergeFrom(const ClientDownloadResponse_MoreInfo& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadResponse.MoreInfo) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + description_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.description_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + description_.Swap(&other->description_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string ClientDownloadResponse_MoreInfo::GetTypeName() const { + return "safe_browsing.ClientDownloadResponse.MoreInfo"; +} + + +// =================================================================== + +void ClientDownloadResponse::InitAsDefaultInstance() { + ::safe_browsing::_ClientDownloadResponse_default_instance_._instance.get_mutable()->more_info_ = const_cast< ::safe_browsing::ClientDownloadResponse_MoreInfo*>( + ::safe_browsing::ClientDownloadResponse_MoreInfo::internal_default_instance()); +} +class ClientDownloadResponse::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadResponse>()._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->more_info_; +} +ClientDownloadResponse::ClientDownloadResponse() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadResponse) +} +ClientDownloadResponse::ClientDownloadResponse(const ClientDownloadResponse& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_token()) { + token_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.token_); + } + if (from._internal_has_more_info()) { + more_info_ = new ::safe_browsing::ClientDownloadResponse_MoreInfo(*from.more_info_); + } else { + more_info_ = nullptr; + } + ::memcpy(&verdict_, &from.verdict_, + static_cast<size_t>(reinterpret_cast<char*>(&upload_) - + reinterpret_cast<char*>(&verdict_)) + sizeof(upload_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadResponse) +} + +void ClientDownloadResponse::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadResponse_csd_2eproto.base); + token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&more_info_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&upload_) - + reinterpret_cast<char*>(&more_info_)) + sizeof(upload_)); +} + +ClientDownloadResponse::~ClientDownloadResponse() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadResponse) + SharedDtor(); +} + +void ClientDownloadResponse::SharedDtor() { + token_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete more_info_; +} + +void ClientDownloadResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadResponse& ClientDownloadResponse::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadResponse_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + token_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(more_info_ != nullptr); + more_info_->Clear(); + } + } + if (cached_has_bits & 0x0000000cu) { + ::memset(&verdict_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&upload_) - + reinterpret_cast<char*>(&verdict_)) + sizeof(upload_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional .safe_browsing.ClientDownloadResponse.Verdict verdict = 1 [default = SAFE]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_token(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool upload = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_upload(&has_bits); + upload_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadResponse::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .safe_browsing.ClientDownloadResponse.Verdict verdict = 1 [default = SAFE]; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_verdict(), target); + } + + // optional .safe_browsing.ClientDownloadResponse.MoreInfo more_info = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::more_info(this), 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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_upload(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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( + *more_info_); + } + + // optional .safe_browsing.ClientDownloadResponse.Verdict verdict = 1 [default = SAFE]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadResponse::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadResponse*>( + &from)); +} + +void ClientDownloadResponse::MergeFrom(const ClientDownloadResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadResponse) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + token_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.token_); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_more_info()->::safe_browsing::ClientDownloadResponse_MoreInfo::MergeFrom(from._internal_more_info()); + } + if (cached_has_bits & 0x00000004u) { + verdict_ = from.verdict_; + } + if (cached_has_bits & 0x00000008u) { + upload_ = from.upload_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + token_.Swap(&other->token_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(more_info_, other->more_info_); + swap(verdict_, other->verdict_); + swap(upload_, other->upload_); +} + +std::string ClientDownloadResponse::GetTypeName() const { + return "safe_browsing.ClientDownloadResponse"; +} + + +// =================================================================== + +void ClientDownloadReport_UserInformation::InitAsDefaultInstance() { +} +class ClientDownloadReport_UserInformation::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadReport_UserInformation>()._has_bits_); + static void set_has_email(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ClientDownloadReport_UserInformation::ClientDownloadReport_UserInformation() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadReport.UserInformation) +} +ClientDownloadReport_UserInformation::ClientDownloadReport_UserInformation(const ClientDownloadReport_UserInformation& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + email_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_email()) { + email_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.email_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadReport.UserInformation) +} + +void ClientDownloadReport_UserInformation::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadReport_UserInformation_csd_2eproto.base); + email_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ClientDownloadReport_UserInformation::~ClientDownloadReport_UserInformation() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadReport.UserInformation) + SharedDtor(); +} + +void ClientDownloadReport_UserInformation::SharedDtor() { + email_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientDownloadReport_UserInformation::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadReport_UserInformation& ClientDownloadReport_UserInformation::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadReport_UserInformation_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadReport_UserInformation::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadReport.UserInformation) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + email_.ClearNonDefaultToEmptyNoArena(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadReport_UserInformation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string email = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_email(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadReport_UserInformation::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadReport.UserInformation) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional string email = 1; + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadReport_UserInformation::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadReport_UserInformation*>( + &from)); +} + +void ClientDownloadReport_UserInformation::MergeFrom(const ClientDownloadReport_UserInformation& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadReport.UserInformation) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_email()) { + _has_bits_[0] |= 0x00000001u; + email_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.email_); + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + email_.Swap(&other->email_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string ClientDownloadReport_UserInformation::GetTypeName() const { + return "safe_browsing.ClientDownloadReport.UserInformation"; +} + + +// =================================================================== + +void ClientDownloadReport::InitAsDefaultInstance() { + ::safe_browsing::_ClientDownloadReport_default_instance_._instance.get_mutable()->download_request_ = const_cast< ::safe_browsing::ClientDownloadRequest*>( + ::safe_browsing::ClientDownloadRequest::internal_default_instance()); + ::safe_browsing::_ClientDownloadReport_default_instance_._instance.get_mutable()->user_information_ = const_cast< ::safe_browsing::ClientDownloadReport_UserInformation*>( + ::safe_browsing::ClientDownloadReport_UserInformation::internal_default_instance()); + ::safe_browsing::_ClientDownloadReport_default_instance_._instance.get_mutable()->download_response_ = const_cast< ::safe_browsing::ClientDownloadResponse*>( + ::safe_browsing::ClientDownloadResponse::internal_default_instance()); +} +class ClientDownloadReport::_Internal { + public: + using HasBits = decltype(std::declval<ClientDownloadReport>()._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->download_request_; +} +const ::safe_browsing::ClientDownloadReport_UserInformation& +ClientDownloadReport::_Internal::user_information(const ClientDownloadReport* msg) { + return *msg->user_information_; +} +const ::safe_browsing::ClientDownloadResponse& +ClientDownloadReport::_Internal::download_response(const ClientDownloadReport* msg) { + return *msg->download_response_; +} +ClientDownloadReport::ClientDownloadReport() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadReport) +} +ClientDownloadReport::ClientDownloadReport(const ClientDownloadReport& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + comment_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_comment()) { + comment_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.comment_); + } + if (from._internal_has_download_request()) { + download_request_ = new ::safe_browsing::ClientDownloadRequest(*from.download_request_); + } else { + download_request_ = nullptr; + } + if (from._internal_has_user_information()) { + user_information_ = new ::safe_browsing::ClientDownloadReport_UserInformation(*from.user_information_); + } else { + user_information_ = nullptr; + } + if (from._internal_has_download_response()) { + download_response_ = new ::safe_browsing::ClientDownloadResponse(*from.download_response_); + } else { + download_response_ = nullptr; + } + reason_ = from.reason_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadReport) +} + +void ClientDownloadReport::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientDownloadReport_csd_2eproto.base); + comment_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&download_request_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&reason_) - + reinterpret_cast<char*>(&download_request_)) + sizeof(reason_)); +} + +ClientDownloadReport::~ClientDownloadReport() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadReport) + SharedDtor(); +} + +void ClientDownloadReport::SharedDtor() { + comment_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete download_request_; + if (this != internal_default_instance()) delete user_information_; + if (this != internal_default_instance()) delete download_response_; +} + +void ClientDownloadReport::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientDownloadReport& ClientDownloadReport::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientDownloadReport_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientDownloadReport::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientDownloadReport) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + comment_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(download_request_ != nullptr); + download_request_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(user_information_ != nullptr); + user_information_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(download_response_ != nullptr); + download_response_->Clear(); + } + } + reason_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientDownloadReport::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional .safe_browsing.ClientDownloadReport.Reason reason = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_comment(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_download_response(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientDownloadReport::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientDownloadReport) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .safe_browsing.ClientDownloadReport.Reason reason = 1; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_reason(), target); + } + + // optional .safe_browsing.ClientDownloadRequest download_request = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::download_request(this), target, stream); + } + + // optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::user_information(this), 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 = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::download_response(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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( + *download_request_); + } + + // optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *user_information_); + } + + // optional .safe_browsing.ClientDownloadResponse download_response = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *download_response_); + } + + // optional .safe_browsing.ClientDownloadReport.Reason reason = 1; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_reason()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientDownloadReport::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientDownloadReport*>( + &from)); +} + +void ClientDownloadReport::MergeFrom(const ClientDownloadReport& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientDownloadReport) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + comment_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.comment_); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_download_request()->::safe_browsing::ClientDownloadRequest::MergeFrom(from._internal_download_request()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_user_information()->::safe_browsing::ClientDownloadReport_UserInformation::MergeFrom(from._internal_user_information()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_download_response()->::safe_browsing::ClientDownloadResponse::MergeFrom(from._internal_download_response()); + } + if (cached_has_bits & 0x00000010u) { + reason_ = from.reason_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 (!download_request_->IsInitialized()) return false; + } + return true; +} + +void ClientDownloadReport::InternalSwap(ClientDownloadReport* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + comment_.Swap(&other->comment_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(download_request_, other->download_request_); + swap(user_information_, other->user_information_); + swap(download_response_, other->download_response_); + swap(reason_, other->reason_); +} + +std::string ClientDownloadReport::GetTypeName() const { + return "safe_browsing.ClientDownloadReport"; +} + + +// =================================================================== + +void ClientUploadResponse::InitAsDefaultInstance() { +} +class ClientUploadResponse::_Internal { + public: + using HasBits = decltype(std::declval<ClientUploadResponse>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientUploadResponse) +} +ClientUploadResponse::ClientUploadResponse(const ClientUploadResponse& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + permalink_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_permalink()) { + permalink_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.permalink_); + } + status_ = from.status_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientUploadResponse) +} + +void ClientUploadResponse::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientUploadResponse_csd_2eproto.base); + permalink_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + status_ = 0; +} + +ClientUploadResponse::~ClientUploadResponse() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientUploadResponse) + SharedDtor(); +} + +void ClientUploadResponse::SharedDtor() { + permalink_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientUploadResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientUploadResponse& ClientUploadResponse::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientUploadResponse_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientUploadResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientUploadResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + permalink_.ClearNonDefaultToEmptyNoArena(); + } + status_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientUploadResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_permalink(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientUploadResponse::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientUploadResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_status()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientUploadResponse::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientUploadResponse*>( + &from)); +} + +void ClientUploadResponse::MergeFrom(const ClientUploadResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientUploadResponse) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + permalink_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.permalink_); + } + if (cached_has_bits & 0x00000002u) { + status_ = from.status_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + permalink_.Swap(&other->permalink_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(status_, other->status_); +} + +std::string ClientUploadResponse::GetTypeName() const { + return "safe_browsing.ClientUploadResponse"; +} + + +// =================================================================== + +void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::InitAsDefaultInstance() { +} +class ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_IncidentData_TrackedPreferenceIncident>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident) +} +ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ClientIncidentReport_IncidentData_TrackedPreferenceIncident(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + split_key_(from.split_key_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_path()) { + path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.path_); + } + atomic_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_atomic_value()) { + atomic_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.atomic_value_); + } + value_state_ = from.value_state_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident) +} + +void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_IncidentData_TrackedPreferenceIncident_csd_2eproto.base); + path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + atomic_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_state_ = 0; +} + +ClientIncidentReport_IncidentData_TrackedPreferenceIncident::~ClientIncidentReport_IncidentData_TrackedPreferenceIncident() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident) + SharedDtor(); +} + +void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::SharedDtor() { + path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + atomic_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& ClientIncidentReport_IncidentData_TrackedPreferenceIncident::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_IncidentData_TrackedPreferenceIncident_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + split_key_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + path_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + atomic_value_.ClearNonDefaultToEmptyNoArena(); + } + } + value_state_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string path = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_path(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string atomic_value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_atomic_value(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string split_key = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_split_key(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->_internal_value_state(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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(split_key_.size()); + for (int i = 0, n = split_key_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + split_key_.Get(i)); + } + + cached_has_bits = _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 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_value_state()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_IncidentData_TrackedPreferenceIncident*>( + &from)); +} + +void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::MergeFrom(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + split_key_.MergeFrom(from.split_key_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.path_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + atomic_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.atomic_value_); + } + if (cached_has_bits & 0x00000004u) { + value_state_ = from.value_state_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + split_key_.InternalSwap(&other->split_key_); + path_.Swap(&other->path_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + atomic_value_.Swap(&other->atomic_value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(value_state_, other->value_state_); +} + +std::string ClientIncidentReport_IncidentData_TrackedPreferenceIncident::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident"; +} + + +// =================================================================== + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::InitAsDefaultInstance() { + ::safe_browsing::_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_default_instance_._instance.get_mutable()->signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>( + ::safe_browsing::ClientDownloadRequest_SignatureInfo::internal_default_instance()); + ::safe_browsing::_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_default_instance_._instance.get_mutable()->image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>( + ::safe_browsing::ClientDownloadRequest_ImageHeaders::internal_default_instance()); +} +class ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile>()._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->signature_; +} +const ::safe_browsing::ClientDownloadRequest_ImageHeaders& +ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_Internal::image_headers(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* msg) { + return *msg->image_headers_; +} +ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(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(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + relative_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_relative_path()) { + relative_path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.relative_path_); + } + if (from._internal_has_signature()) { + signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo(*from.signature_); + } else { + signature_ = nullptr; + } + if (from._internal_has_image_headers()) { + image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders(*from.image_headers_); + } else { + image_headers_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile) +} + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_csd_2eproto.base); + relative_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&signature_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&image_headers_) - + reinterpret_cast<char*>(&signature_)) + sizeof(image_headers_)); +} + +ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::~ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile) + SharedDtor(); +} + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::SharedDtor() { + relative_path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete signature_; + if (this != internal_default_instance()) delete image_headers_; +} + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + relative_path_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(signature_ != nullptr); + signature_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(image_headers_ != nullptr); + image_headers_->Clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string relative_path = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_relative_path(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_image_headers(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::signature(this), target, stream); + } + + // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::image_headers(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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( + *signature_); + } + + // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *image_headers_); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile*>( + &from)); +} + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::MergeFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + relative_path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.relative_path_); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(from._internal_signature()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(from._internal_image_headers()); + } + } +} + +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 (!signature_->IsInitialized()) return false; + } + if (_internal_has_image_headers()) { + if (!image_headers_->IsInitialized()) return false; + } + return true; +} + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::InternalSwap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + relative_path_.Swap(&other->relative_path_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(signature_, other->signature_); + swap(image_headers_, other->image_headers_); +} + +std::string ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile"; +} + + +// =================================================================== + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::InitAsDefaultInstance() { + ::safe_browsing::_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_default_instance_._instance.get_mutable()->signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>( + ::safe_browsing::ClientDownloadRequest_SignatureInfo::internal_default_instance()); + ::safe_browsing::_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_default_instance_._instance.get_mutable()->image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>( + ::safe_browsing::ClientDownloadRequest_ImageHeaders::internal_default_instance()); +} +class ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_IncidentData_BinaryIntegrityIncident>()._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->signature_; +} +const ::safe_browsing::ClientDownloadRequest_ImageHeaders& +ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_Internal::image_headers(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident* msg) { + return *msg->image_headers_; +} +ClientIncidentReport_IncidentData_BinaryIntegrityIncident::ClientIncidentReport_IncidentData_BinaryIntegrityIncident() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident) +} +ClientIncidentReport_IncidentData_BinaryIntegrityIncident::ClientIncidentReport_IncidentData_BinaryIntegrityIncident(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + contained_file_(from.contained_file_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + file_basename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_file_basename()) { + file_basename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.file_basename_); + } + if (from._internal_has_signature()) { + signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo(*from.signature_); + } else { + signature_ = nullptr; + } + if (from._internal_has_image_headers()) { + image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders(*from.image_headers_); + } else { + image_headers_ = nullptr; + } + sec_error_ = from.sec_error_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident) +} + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_csd_2eproto.base); + file_basename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&signature_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&sec_error_) - + reinterpret_cast<char*>(&signature_)) + sizeof(sec_error_)); +} + +ClientIncidentReport_IncidentData_BinaryIntegrityIncident::~ClientIncidentReport_IncidentData_BinaryIntegrityIncident() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident) + SharedDtor(); +} + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::SharedDtor() { + file_basename_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete signature_; + if (this != internal_default_instance()) delete image_headers_; +} + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_IncidentData_BinaryIntegrityIncident_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + contained_file_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + file_basename_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(signature_ != nullptr); + signature_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(image_headers_ != nullptr); + image_headers_->Clear(); + } + } + sec_error_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string file_basename = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_file_basename(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_sec_error(&has_bits); + sec_error_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::signature(this), target, stream); + } + + // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::image_headers(this), target, stream); + } + + // optional int32 sec_error = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_sec_error(), target); + } + + // repeated .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile contained_file = 5; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_contained_file_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, this->_internal_contained_file(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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->contained_file_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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( + *signature_); + } + + // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *image_headers_); + } + + // optional int32 sec_error = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_sec_error()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_IncidentData_BinaryIntegrityIncident*>( + &from)); +} + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::MergeFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + contained_file_.MergeFrom(from.contained_file_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + file_basename_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.file_basename_); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(from._internal_signature()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(from._internal_image_headers()); + } + if (cached_has_bits & 0x00000008u) { + sec_error_ = from.sec_error_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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(contained_file_)) return false; + if (_internal_has_signature()) { + if (!signature_->IsInitialized()) return false; + } + if (_internal_has_image_headers()) { + if (!image_headers_->IsInitialized()) return false; + } + return true; +} + +void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::InternalSwap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + contained_file_.InternalSwap(&other->contained_file_); + file_basename_.Swap(&other->file_basename_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(signature_, other->signature_); + swap(image_headers_, other->image_headers_); + swap(sec_error_, other->sec_error_); +} + +std::string ClientIncidentReport_IncidentData_BinaryIntegrityIncident::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident"; +} + + +// =================================================================== + +void ClientIncidentReport_IncidentData_ResourceRequestIncident::InitAsDefaultInstance() { +} +class ClientIncidentReport_IncidentData_ResourceRequestIncident::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_IncidentData_ResourceRequestIncident>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident) +} +ClientIncidentReport_IncidentData_ResourceRequestIncident::ClientIncidentReport_IncidentData_ResourceRequestIncident(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + digest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_digest()) { + digest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.digest_); + } + origin_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_origin()) { + origin_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.origin_); + } + type_ = from.type_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident) +} + +void ClientIncidentReport_IncidentData_ResourceRequestIncident::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_IncidentData_ResourceRequestIncident_csd_2eproto.base); + digest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + origin_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + type_ = 0; +} + +ClientIncidentReport_IncidentData_ResourceRequestIncident::~ClientIncidentReport_IncidentData_ResourceRequestIncident() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident) + SharedDtor(); +} + +void ClientIncidentReport_IncidentData_ResourceRequestIncident::SharedDtor() { + digest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + origin_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientIncidentReport_IncidentData_ResourceRequestIncident::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_IncidentData_ResourceRequestIncident& ClientIncidentReport_IncidentData_ResourceRequestIncident::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_IncidentData_ResourceRequestIncident_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_IncidentData_ResourceRequestIncident::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + digest_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + origin_.ClearNonDefaultToEmptyNoArena(); + } + } + type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_IncidentData_ResourceRequestIncident::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional bytes digest = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_digest(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string origin = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_origin(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_IncidentData_ResourceRequestIncident::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_type(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_IncidentData_ResourceRequestIncident::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_IncidentData_ResourceRequestIncident*>( + &from)); +} + +void ClientIncidentReport_IncidentData_ResourceRequestIncident::MergeFrom(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + digest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.digest_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + origin_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.origin_); + } + if (cached_has_bits & 0x00000004u) { + type_ = from.type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + digest_.Swap(&other->digest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + origin_.Swap(&other->origin_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(type_, other->type_); +} + +std::string ClientIncidentReport_IncidentData_ResourceRequestIncident::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident"; +} + + +// =================================================================== + +void ClientIncidentReport_IncidentData::InitAsDefaultInstance() { + ::safe_browsing::_ClientIncidentReport_IncidentData_default_instance_._instance.get_mutable()->tracked_preference_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident*>( + ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident::internal_default_instance()); + ::safe_browsing::_ClientIncidentReport_IncidentData_default_instance_._instance.get_mutable()->binary_integrity_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident*>( + ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident::internal_default_instance()); + ::safe_browsing::_ClientIncidentReport_IncidentData_default_instance_._instance.get_mutable()->resource_request_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident*>( + ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident::internal_default_instance()); +} +class ClientIncidentReport_IncidentData::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_IncidentData>()._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->tracked_preference_; +} +const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident& +ClientIncidentReport_IncidentData::_Internal::binary_integrity(const ClientIncidentReport_IncidentData* msg) { + return *msg->binary_integrity_; +} +const ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident& +ClientIncidentReport_IncidentData::_Internal::resource_request(const ClientIncidentReport_IncidentData* msg) { + return *msg->resource_request_; +} +ClientIncidentReport_IncidentData::ClientIncidentReport_IncidentData() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.IncidentData) +} +ClientIncidentReport_IncidentData::ClientIncidentReport_IncidentData(const ClientIncidentReport_IncidentData& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_tracked_preference()) { + tracked_preference_ = new ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident(*from.tracked_preference_); + } else { + tracked_preference_ = nullptr; + } + if (from._internal_has_binary_integrity()) { + binary_integrity_ = new ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident(*from.binary_integrity_); + } else { + binary_integrity_ = nullptr; + } + if (from._internal_has_resource_request()) { + resource_request_ = new ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident(*from.resource_request_); + } else { + resource_request_ = nullptr; + } + incident_time_msec_ = from.incident_time_msec_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData) +} + +void ClientIncidentReport_IncidentData::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_IncidentData_csd_2eproto.base); + ::memset(&tracked_preference_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&incident_time_msec_) - + reinterpret_cast<char*>(&tracked_preference_)) + sizeof(incident_time_msec_)); +} + +ClientIncidentReport_IncidentData::~ClientIncidentReport_IncidentData() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData) + SharedDtor(); +} + +void ClientIncidentReport_IncidentData::SharedDtor() { + if (this != internal_default_instance()) delete tracked_preference_; + if (this != internal_default_instance()) delete binary_integrity_; + if (this != internal_default_instance()) delete resource_request_; +} + +void ClientIncidentReport_IncidentData::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_IncidentData& ClientIncidentReport_IncidentData::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_IncidentData_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_IncidentData::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.IncidentData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(tracked_preference_ != nullptr); + tracked_preference_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(binary_integrity_ != nullptr); + binary_integrity_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(resource_request_ != nullptr); + resource_request_->Clear(); + } + } + incident_time_msec_ = PROTOBUF_LONGLONG(0); + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_IncidentData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional int64 incident_time_msec = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_incident_time_msec(&has_bits); + incident_time_msec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_resource_request(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_IncidentData::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.IncidentData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int64 incident_time_msec = 1; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_incident_time_msec(), target); + } + + // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident tracked_preference = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::tracked_preference(this), target, stream); + } + + // optional .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident binary_integrity = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::binary_integrity(this), target, stream); + } + + // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident resource_request = 7; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::resource_request(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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( + *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( + *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( + *resource_request_); + } + + // optional int64 incident_time_msec = 1; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_incident_time_msec()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_IncidentData::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_IncidentData*>( + &from)); +} + +void ClientIncidentReport_IncidentData::MergeFrom(const ClientIncidentReport_IncidentData& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.IncidentData) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_tracked_preference()->::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident::MergeFrom(from._internal_tracked_preference()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_binary_integrity()->::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident::MergeFrom(from._internal_binary_integrity()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_resource_request()->::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident::MergeFrom(from._internal_resource_request()); + } + if (cached_has_bits & 0x00000008u) { + incident_time_msec_ = from.incident_time_msec_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 (!binary_integrity_->IsInitialized()) return false; + } + return true; +} + +void ClientIncidentReport_IncidentData::InternalSwap(ClientIncidentReport_IncidentData* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(tracked_preference_, other->tracked_preference_); + swap(binary_integrity_, other->binary_integrity_); + swap(resource_request_, other->resource_request_); + swap(incident_time_msec_, other->incident_time_msec_); +} + +std::string ClientIncidentReport_IncidentData::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.IncidentData"; +} + + +// =================================================================== + +void ClientIncidentReport_DownloadDetails::InitAsDefaultInstance() { + ::safe_browsing::_ClientIncidentReport_DownloadDetails_default_instance_._instance.get_mutable()->download_ = const_cast< ::safe_browsing::ClientDownloadRequest*>( + ::safe_browsing::ClientDownloadRequest::internal_default_instance()); +} +class ClientIncidentReport_DownloadDetails::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_DownloadDetails>()._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->download_; +} +ClientIncidentReport_DownloadDetails::ClientIncidentReport_DownloadDetails() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.DownloadDetails) +} +ClientIncidentReport_DownloadDetails::ClientIncidentReport_DownloadDetails(const ClientIncidentReport_DownloadDetails& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_token()) { + token_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.token_); + } + if (from._internal_has_download()) { + download_ = new ::safe_browsing::ClientDownloadRequest(*from.download_); + } else { + download_ = nullptr; + } + ::memcpy(&download_time_msec_, &from.download_time_msec_, + static_cast<size_t>(reinterpret_cast<char*>(&open_time_msec_) - + reinterpret_cast<char*>(&download_time_msec_)) + sizeof(open_time_msec_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.DownloadDetails) +} + +void ClientIncidentReport_DownloadDetails::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_DownloadDetails_csd_2eproto.base); + token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&download_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&open_time_msec_) - + reinterpret_cast<char*>(&download_)) + sizeof(open_time_msec_)); +} + +ClientIncidentReport_DownloadDetails::~ClientIncidentReport_DownloadDetails() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.DownloadDetails) + SharedDtor(); +} + +void ClientIncidentReport_DownloadDetails::SharedDtor() { + token_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete download_; +} + +void ClientIncidentReport_DownloadDetails::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_DownloadDetails& ClientIncidentReport_DownloadDetails::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_DownloadDetails_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_DownloadDetails::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.DownloadDetails) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + token_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(download_ != nullptr); + download_->Clear(); + } + } + if (cached_has_bits & 0x0000000cu) { + ::memset(&download_time_msec_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&open_time_msec_) - + reinterpret_cast<char*>(&download_time_msec_)) + sizeof(open_time_msec_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_DownloadDetails::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional bytes token = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_token(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_download_time_msec(&has_bits); + download_time_msec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional int64 open_time_msec = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_open_time_msec(&has_bits); + open_time_msec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_DownloadDetails::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.DownloadDetails) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::download(this), target, stream); + } + + // optional int64 download_time_msec = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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( + *download_); + } + + // optional int64 download_time_msec = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_download_time_msec()); + } + + // optional int64 open_time_msec = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_open_time_msec()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_DownloadDetails::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_DownloadDetails*>( + &from)); +} + +void ClientIncidentReport_DownloadDetails::MergeFrom(const ClientIncidentReport_DownloadDetails& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.DownloadDetails) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + token_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.token_); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_download()->::safe_browsing::ClientDownloadRequest::MergeFrom(from._internal_download()); + } + if (cached_has_bits & 0x00000004u) { + download_time_msec_ = from.download_time_msec_; + } + if (cached_has_bits & 0x00000008u) { + open_time_msec_ = from.open_time_msec_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 (!download_->IsInitialized()) return false; + } + return true; +} + +void ClientIncidentReport_DownloadDetails::InternalSwap(ClientIncidentReport_DownloadDetails* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + token_.Swap(&other->token_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(download_, other->download_); + swap(download_time_msec_, other->download_time_msec_); + swap(open_time_msec_, other->open_time_msec_); +} + +std::string ClientIncidentReport_DownloadDetails::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.DownloadDetails"; +} + + +// =================================================================== + +void ClientIncidentReport_EnvironmentData_OS_RegistryValue::InitAsDefaultInstance() { +} +class ClientIncidentReport_EnvironmentData_OS_RegistryValue::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_OS_RegistryValue>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(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(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_data()) { + data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_); + } + type_ = from.type_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue) +} + +void ClientIncidentReport_EnvironmentData_OS_RegistryValue::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_EnvironmentData_OS_RegistryValue_csd_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + type_ = 0u; +} + +ClientIncidentReport_EnvironmentData_OS_RegistryValue::~ClientIncidentReport_EnvironmentData_OS_RegistryValue() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue) + SharedDtor(); +} + +void ClientIncidentReport_EnvironmentData_OS_RegistryValue::SharedDtor() { + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientIncidentReport_EnvironmentData_OS_RegistryValue::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_EnvironmentData_OS_RegistryValue& ClientIncidentReport_EnvironmentData_OS_RegistryValue::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_EnvironmentData_OS_RegistryValue_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_EnvironmentData_OS_RegistryValue::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + data_.ClearNonDefaultToEmptyNoArena(); + } + } + type_ = 0u; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_EnvironmentData_OS_RegistryValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_type(&has_bits); + type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes data = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_data(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_EnvironmentData_OS_RegistryValue::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_EnvironmentData_OS_RegistryValue::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_EnvironmentData_OS_RegistryValue*>( + &from)); +} + +void ClientIncidentReport_EnvironmentData_OS_RegistryValue::MergeFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_); + } + if (cached_has_bits & 0x00000004u) { + type_ = from.type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(type_, other->type_); +} + +std::string ClientIncidentReport_EnvironmentData_OS_RegistryValue::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue"; +} + + +// =================================================================== + +void ClientIncidentReport_EnvironmentData_OS_RegistryKey::InitAsDefaultInstance() { +} +class ClientIncidentReport_EnvironmentData_OS_RegistryKey::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_OS_RegistryKey>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(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(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + value_(from.value_), + key_(from.key_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey) +} + +void ClientIncidentReport_EnvironmentData_OS_RegistryKey::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_EnvironmentData_OS_RegistryKey_csd_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ClientIncidentReport_EnvironmentData_OS_RegistryKey::~ClientIncidentReport_EnvironmentData_OS_RegistryKey() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey) + SharedDtor(); +} + +void ClientIncidentReport_EnvironmentData_OS_RegistryKey::SharedDtor() { + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientIncidentReport_EnvironmentData_OS_RegistryKey::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_EnvironmentData_OS_RegistryKey& ClientIncidentReport_EnvironmentData_OS_RegistryKey::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_EnvironmentData_OS_RegistryKey_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_EnvironmentData_OS_RegistryKey::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + value_.Clear(); + key_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmptyNoArena(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_EnvironmentData_OS_RegistryKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_EnvironmentData_OS_RegistryKey::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 int i = 0, + n = static_cast<unsigned int>(this->_internal_value_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_value(i), target, stream); + } + + // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey key = 3; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_key_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_key(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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->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->key_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional string name = 1; + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_EnvironmentData_OS_RegistryKey::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_EnvironmentData_OS_RegistryKey*>( + &from)); +} + +void ClientIncidentReport_EnvironmentData_OS_RegistryKey::MergeFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + value_.MergeFrom(from.value_); + key_.MergeFrom(from.key_); + if (from._internal_has_name()) { + _has_bits_[0] |= 0x00000001u; + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + value_.InternalSwap(&other->value_); + key_.InternalSwap(&other->key_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string ClientIncidentReport_EnvironmentData_OS_RegistryKey::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey"; +} + + +// =================================================================== + +void ClientIncidentReport_EnvironmentData_OS::InitAsDefaultInstance() { +} +class ClientIncidentReport_EnvironmentData_OS::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_OS>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS) +} +ClientIncidentReport_EnvironmentData_OS::ClientIncidentReport_EnvironmentData_OS(const ClientIncidentReport_EnvironmentData_OS& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + registry_key_(from.registry_key_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + os_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_os_name()) { + os_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.os_name_); + } + os_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_os_version()) { + os_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.os_version_); + } + is_enrolled_to_domain_ = from.is_enrolled_to_domain_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS) +} + +void ClientIncidentReport_EnvironmentData_OS::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_EnvironmentData_OS_csd_2eproto.base); + os_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + os_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + is_enrolled_to_domain_ = false; +} + +ClientIncidentReport_EnvironmentData_OS::~ClientIncidentReport_EnvironmentData_OS() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS) + SharedDtor(); +} + +void ClientIncidentReport_EnvironmentData_OS::SharedDtor() { + os_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + os_version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientIncidentReport_EnvironmentData_OS::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_EnvironmentData_OS& ClientIncidentReport_EnvironmentData_OS::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_EnvironmentData_OS_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_EnvironmentData_OS::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + registry_key_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + os_name_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + os_version_.ClearNonDefaultToEmptyNoArena(); + } + } + is_enrolled_to_domain_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_EnvironmentData_OS::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string os_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_os_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string os_version = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_os_version(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_is_enrolled_to_domain(&has_bits); + is_enrolled_to_domain_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_EnvironmentData_OS::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 int i = 0, + n = static_cast<unsigned int>(this->_internal_registry_key_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_registry_key(i), target, stream); + } + + // optional bool is_enrolled_to_domain = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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->registry_key_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_EnvironmentData_OS::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_EnvironmentData_OS*>( + &from)); +} + +void ClientIncidentReport_EnvironmentData_OS::MergeFrom(const ClientIncidentReport_EnvironmentData_OS& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + registry_key_.MergeFrom(from.registry_key_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + os_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.os_name_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + os_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.os_version_); + } + if (cached_has_bits & 0x00000004u) { + is_enrolled_to_domain_ = from.is_enrolled_to_domain_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + registry_key_.InternalSwap(&other->registry_key_); + os_name_.Swap(&other->os_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + os_version_.Swap(&other->os_version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(is_enrolled_to_domain_, other->is_enrolled_to_domain_); +} + +std::string ClientIncidentReport_EnvironmentData_OS::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.EnvironmentData.OS"; +} + + +// =================================================================== + +void ClientIncidentReport_EnvironmentData_Machine::InitAsDefaultInstance() { +} +class ClientIncidentReport_EnvironmentData_Machine::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_Machine>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Machine) +} +ClientIncidentReport_EnvironmentData_Machine::ClientIncidentReport_EnvironmentData_Machine(const ClientIncidentReport_EnvironmentData_Machine& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + cpu_architecture_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_cpu_architecture()) { + cpu_architecture_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cpu_architecture_); + } + cpu_vendor_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_cpu_vendor()) { + cpu_vendor_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cpu_vendor_); + } + cpuid_ = from.cpuid_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Machine) +} + +void ClientIncidentReport_EnvironmentData_Machine::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_EnvironmentData_Machine_csd_2eproto.base); + cpu_architecture_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + cpu_vendor_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + cpuid_ = 0u; +} + +ClientIncidentReport_EnvironmentData_Machine::~ClientIncidentReport_EnvironmentData_Machine() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Machine) + SharedDtor(); +} + +void ClientIncidentReport_EnvironmentData_Machine::SharedDtor() { + cpu_architecture_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + cpu_vendor_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientIncidentReport_EnvironmentData_Machine::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_EnvironmentData_Machine& ClientIncidentReport_EnvironmentData_Machine::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_EnvironmentData_Machine_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_EnvironmentData_Machine::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Machine) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + cpu_architecture_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + cpu_vendor_.ClearNonDefaultToEmptyNoArena(); + } + } + cpuid_ = 0u; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_EnvironmentData_Machine::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string cpu_architecture = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_cpu_architecture(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string cpu_vendor = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_cpu_vendor(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 cpuid = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_cpuid(&has_bits); + cpuid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_EnvironmentData_Machine::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Machine) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_cpuid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_cpuid()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_EnvironmentData_Machine::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_EnvironmentData_Machine*>( + &from)); +} + +void ClientIncidentReport_EnvironmentData_Machine::MergeFrom(const ClientIncidentReport_EnvironmentData_Machine& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Machine) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + cpu_architecture_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cpu_architecture_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + cpu_vendor_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cpu_vendor_); + } + if (cached_has_bits & 0x00000004u) { + cpuid_ = from.cpuid_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + cpu_architecture_.Swap(&other->cpu_architecture_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + cpu_vendor_.Swap(&other->cpu_vendor_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(cpuid_, other->cpuid_); +} + +std::string ClientIncidentReport_EnvironmentData_Machine::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Machine"; +} + + +// =================================================================== + +void ClientIncidentReport_EnvironmentData_Process_Patch::InitAsDefaultInstance() { +} +class ClientIncidentReport_EnvironmentData_Process_Patch::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_Process_Patch>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(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(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_function()) { + function_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.function_); + } + target_dll_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_target_dll()) { + target_dll_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.target_dll_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch) +} + +void ClientIncidentReport_EnvironmentData_Process_Patch::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_EnvironmentData_Process_Patch_csd_2eproto.base); + function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + target_dll_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ClientIncidentReport_EnvironmentData_Process_Patch::~ClientIncidentReport_EnvironmentData_Process_Patch() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch) + SharedDtor(); +} + +void ClientIncidentReport_EnvironmentData_Process_Patch::SharedDtor() { + function_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + target_dll_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientIncidentReport_EnvironmentData_Process_Patch::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_EnvironmentData_Process_Patch& ClientIncidentReport_EnvironmentData_Process_Patch::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_EnvironmentData_Process_Patch_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_EnvironmentData_Process_Patch::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + function_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + target_dll_.ClearNonDefaultToEmptyNoArena(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_EnvironmentData_Process_Patch::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string function = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_function(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string target_dll = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_target_dll(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_EnvironmentData_Process_Patch::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_EnvironmentData_Process_Patch::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_EnvironmentData_Process_Patch*>( + &from)); +} + +void ClientIncidentReport_EnvironmentData_Process_Patch::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_Patch& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + function_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.function_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + target_dll_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.target_dll_); + } + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + function_.Swap(&other->function_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + target_dll_.Swap(&other->target_dll_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string ClientIncidentReport_EnvironmentData_Process_Patch::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch"; +} + + +// =================================================================== + +void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::InitAsDefaultInstance() { +} +class ClientIncidentReport_EnvironmentData_Process_NetworkProvider::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_Process_NetworkProvider>()._has_bits_); +}; + +ClientIncidentReport_EnvironmentData_Process_NetworkProvider::ClientIncidentReport_EnvironmentData_Process_NetworkProvider() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(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(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider) +} + +void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::SharedCtor() { +} + +ClientIncidentReport_EnvironmentData_Process_NetworkProvider::~ClientIncidentReport_EnvironmentData_Process_NetworkProvider() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider) + SharedDtor(); +} + +void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::SharedDtor() { +} + +void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& ClientIncidentReport_EnvironmentData_Process_NetworkProvider::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_EnvironmentData_Process_NetworkProvider_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_EnvironmentData_Process_NetworkProvider::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_EnvironmentData_Process_NetworkProvider::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_EnvironmentData_Process_NetworkProvider*>( + &from)); +} + +void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + +} + +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_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); +} + +std::string ClientIncidentReport_EnvironmentData_Process_NetworkProvider::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider"; +} + + +// =================================================================== + +void ClientIncidentReport_EnvironmentData_Process_Dll::InitAsDefaultInstance() { + ::safe_browsing::_ClientIncidentReport_EnvironmentData_Process_Dll_default_instance_._instance.get_mutable()->image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>( + ::safe_browsing::ClientDownloadRequest_ImageHeaders::internal_default_instance()); +} +class ClientIncidentReport_EnvironmentData_Process_Dll::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_Process_Dll>()._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->image_headers_; +} +ClientIncidentReport_EnvironmentData_Process_Dll::ClientIncidentReport_EnvironmentData_Process_Dll() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(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(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + feature_(from.feature_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_path()) { + path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.path_); + } + if (from._internal_has_image_headers()) { + image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders(*from.image_headers_); + } else { + image_headers_ = nullptr; + } + ::memcpy(&base_address_, &from.base_address_, + static_cast<size_t>(reinterpret_cast<char*>(&length_) - + reinterpret_cast<char*>(&base_address_)) + sizeof(length_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll) +} + +void ClientIncidentReport_EnvironmentData_Process_Dll::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_EnvironmentData_Process_Dll_csd_2eproto.base); + path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&image_headers_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&length_) - + reinterpret_cast<char*>(&image_headers_)) + sizeof(length_)); +} + +ClientIncidentReport_EnvironmentData_Process_Dll::~ClientIncidentReport_EnvironmentData_Process_Dll() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll) + SharedDtor(); +} + +void ClientIncidentReport_EnvironmentData_Process_Dll::SharedDtor() { + path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete image_headers_; +} + +void ClientIncidentReport_EnvironmentData_Process_Dll::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_EnvironmentData_Process_Dll& ClientIncidentReport_EnvironmentData_Process_Dll::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_EnvironmentData_Process_Dll_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_EnvironmentData_Process_Dll::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + feature_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + path_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(image_headers_ != nullptr); + image_headers_->Clear(); + } + } + if (cached_has_bits & 0x0000000cu) { + ::memset(&base_address_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&length_) - + reinterpret_cast<char*>(&base_address_)) + sizeof(length_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_EnvironmentData_Process_Dll::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string path = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_path(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint64 base_address = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_base_address(&has_bits); + base_address_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional uint32 length = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_length(&has_bits); + length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ptr -= 1; + do { + ptr += 1; + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_image_headers(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_EnvironmentData_Process_Dll::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->_internal_base_address(), target); + } + + // optional uint32 length = 3; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->_internal_feature(i), target); + } + + // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::image_headers(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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 += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize( + this->_internal_feature(static_cast<int>(i))); + } + total_size += (1UL * count) + data_size; + } + + cached_has_bits = _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( + *image_headers_); + } + + // optional uint64 base_address = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_base_address()); + } + + // optional uint32 length = 3; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_length()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_EnvironmentData_Process_Dll::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_EnvironmentData_Process_Dll*>( + &from)); +} + +void ClientIncidentReport_EnvironmentData_Process_Dll::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_Dll& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + feature_.MergeFrom(from.feature_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + path_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.path_); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(from._internal_image_headers()); + } + if (cached_has_bits & 0x00000004u) { + base_address_ = from.base_address_; + } + if (cached_has_bits & 0x00000008u) { + length_ = from.length_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 (!image_headers_->IsInitialized()) return false; + } + return true; +} + +void ClientIncidentReport_EnvironmentData_Process_Dll::InternalSwap(ClientIncidentReport_EnvironmentData_Process_Dll* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + feature_.InternalSwap(&other->feature_); + path_.Swap(&other->path_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(image_headers_, other->image_headers_); + swap(base_address_, other->base_address_); + swap(length_, other->length_); +} + +std::string ClientIncidentReport_EnvironmentData_Process_Dll::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll"; +} + + +// =================================================================== + +void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::InitAsDefaultInstance() { +} +class ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(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(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + modified_bytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_modified_bytes()) { + modified_bytes_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.modified_bytes_); + } + export_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_export_name()) { + export_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.export_name_); + } + ::memcpy(&file_offset_, &from.file_offset_, + static_cast<size_t>(reinterpret_cast<char*>(&byte_count_) - + reinterpret_cast<char*>(&file_offset_)) + sizeof(byte_count_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification) +} + +void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification_csd_2eproto.base); + modified_bytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + export_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&file_offset_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&byte_count_) - + reinterpret_cast<char*>(&file_offset_)) + sizeof(byte_count_)); +} + +ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::~ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification) + SharedDtor(); +} + +void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::SharedDtor() { + modified_bytes_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + export_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + modified_bytes_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + export_name_.ClearNonDefaultToEmptyNoArena(); + } + } + if (cached_has_bits & 0x0000000cu) { + ::memset(&file_offset_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&byte_count_) - + reinterpret_cast<char*>(&file_offset_)) + sizeof(byte_count_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 file_offset = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_file_offset(&has_bits); + file_offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional int32 byte_count = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_byte_count(&has_bits); + byte_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes modified_bytes = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_modified_bytes(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string export_name = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_export_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 file_offset = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_file_offset(), target); + } + + // optional int32 byte_count = 2; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_file_offset()); + } + + // optional int32 byte_count = 2; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_byte_count()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification*>( + &from)); +} + +void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + modified_bytes_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.modified_bytes_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + export_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.export_name_); + } + if (cached_has_bits & 0x00000004u) { + file_offset_ = from.file_offset_; + } + if (cached_has_bits & 0x00000008u) { + byte_count_ = from.byte_count_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + modified_bytes_.Swap(&other->modified_bytes_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + export_name_.Swap(&other->export_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(file_offset_, other->file_offset_); + swap(byte_count_, other->byte_count_); +} + +std::string ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification"; +} + + +// =================================================================== + +void ClientIncidentReport_EnvironmentData_Process_ModuleState::InitAsDefaultInstance() { +} +class ClientIncidentReport_EnvironmentData_Process_ModuleState::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_Process_ModuleState>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(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(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + obsolete_modified_export_(from.obsolete_modified_export_), + modification_(from.modification_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + modified_state_ = from.modified_state_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState) +} + +void ClientIncidentReport_EnvironmentData_Process_ModuleState::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_csd_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + modified_state_ = 0; +} + +ClientIncidentReport_EnvironmentData_Process_ModuleState::~ClientIncidentReport_EnvironmentData_Process_ModuleState() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState) + SharedDtor(); +} + +void ClientIncidentReport_EnvironmentData_Process_ModuleState::SharedDtor() { + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientIncidentReport_EnvironmentData_Process_ModuleState::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_EnvironmentData_Process_ModuleState& ClientIncidentReport_EnvironmentData_Process_ModuleState::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_EnvironmentData_Process_ModuleState_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_EnvironmentData_Process_ModuleState::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + obsolete_modified_export_.Clear(); + modification_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmptyNoArena(); + } + modified_state_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_EnvironmentData_Process_ModuleState::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_obsolete_modified_export(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_EnvironmentData_Process_ModuleState::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::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 int i = 0, + n = static_cast<unsigned int>(this->_internal_modification_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, this->_internal_modification(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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(obsolete_modified_export_.size()); + for (int i = 0, n = obsolete_modified_export_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + 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->modification_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_modified_state()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_EnvironmentData_Process_ModuleState::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_EnvironmentData_Process_ModuleState*>( + &from)); +} + +void ClientIncidentReport_EnvironmentData_Process_ModuleState::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + obsolete_modified_export_.MergeFrom(from.obsolete_modified_export_); + modification_.MergeFrom(from.modification_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (cached_has_bits & 0x00000002u) { + modified_state_ = from.modified_state_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + obsolete_modified_export_.InternalSwap(&other->obsolete_modified_export_); + modification_.InternalSwap(&other->modification_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(modified_state_, other->modified_state_); +} + +std::string ClientIncidentReport_EnvironmentData_Process_ModuleState::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState"; +} + + +// =================================================================== + +void ClientIncidentReport_EnvironmentData_Process::InitAsDefaultInstance() { +} +class ClientIncidentReport_EnvironmentData_Process::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData_Process>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process) +} +ClientIncidentReport_EnvironmentData_Process::ClientIncidentReport_EnvironmentData_Process(const ClientIncidentReport_EnvironmentData_Process& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + obsolete_dlls_(from.obsolete_dlls_), + patches_(from.patches_), + network_providers_(from.network_providers_), + dll_(from.dll_), + blacklisted_dll_(from.blacklisted_dll_), + module_state_(from.module_state_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_version()) { + version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.version_); + } + ::memcpy(&uptime_msec_, &from.uptime_msec_, + static_cast<size_t>(reinterpret_cast<char*>(&obsolete_field_trial_participant_) - + reinterpret_cast<char*>(&uptime_msec_)) + sizeof(obsolete_field_trial_participant_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process) +} + +void ClientIncidentReport_EnvironmentData_Process::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_EnvironmentData_Process_csd_2eproto.base); + version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&uptime_msec_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&obsolete_field_trial_participant_) - + reinterpret_cast<char*>(&uptime_msec_)) + sizeof(obsolete_field_trial_participant_)); +} + +ClientIncidentReport_EnvironmentData_Process::~ClientIncidentReport_EnvironmentData_Process() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process) + SharedDtor(); +} + +void ClientIncidentReport_EnvironmentData_Process::SharedDtor() { + version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientIncidentReport_EnvironmentData_Process::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_EnvironmentData_Process& ClientIncidentReport_EnvironmentData_Process::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_EnvironmentData_Process_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_EnvironmentData_Process::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + obsolete_dlls_.Clear(); + patches_.Clear(); + network_providers_.Clear(); + dll_.Clear(); + blacklisted_dll_.Clear(); + module_state_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + version_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x0000003eu) { + ::memset(&uptime_msec_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&obsolete_field_trial_participant_) - + reinterpret_cast<char*>(&uptime_msec_)) + sizeof(obsolete_field_trial_participant_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_EnvironmentData_Process::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string version = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_version(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string OBSOLETE_dlls = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_obsolete_dlls(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + _Internal::set_has_uptime_msec(&has_bits); + uptime_msec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool metrics_consent = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + _Internal::set_has_metrics_consent(&has_bits); + metrics_consent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool OBSOLETE_extended_consent = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + _Internal::set_has_obsolete_extended_consent(&has_bits); + obsolete_extended_consent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_blacklisted_dll(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) { + _Internal::set_has_obsolete_field_trial_participant(&has_bits); + obsolete_field_trial_participant_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_EnvironmentData_Process::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 int i = 0, + n = static_cast<unsigned int>(this->_internal_patches_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_patches(i), target, stream); + } + + // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider network_providers = 4; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_network_providers_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, this->_internal_network_providers(i), target, stream); + } + + // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Channel chrome_update_channel = 5; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 5, this->_internal_chrome_update_channel(), target); + } + + // optional int64 uptime_msec = 6; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(6, this->_internal_uptime_msec(), target); + } + + // optional bool metrics_consent = 7; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_metrics_consent(), target); + } + + // optional bool OBSOLETE_extended_consent = 8; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_obsolete_extended_consent(), target); + } + + // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll dll = 9; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_dll_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(9, this->_internal_dll(i), 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 int i = 0, + n = static_cast<unsigned int>(this->_internal_module_state_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(11, this->_internal_module_state(i), target, stream); + } + + // optional bool OBSOLETE_field_trial_participant = 12; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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(obsolete_dlls_.size()); + for (int i = 0, n = obsolete_dlls_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + 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->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->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->dll_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated string blacklisted_dll = 10; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(blacklisted_dll_.size()); + for (int i = 0, n = blacklisted_dll_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + 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->module_state_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_uptime_msec()); + } + + // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Channel chrome_update_channel = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_EnvironmentData_Process::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_EnvironmentData_Process*>( + &from)); +} + +void ClientIncidentReport_EnvironmentData_Process::MergeFrom(const ClientIncidentReport_EnvironmentData_Process& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + obsolete_dlls_.MergeFrom(from.obsolete_dlls_); + patches_.MergeFrom(from.patches_); + network_providers_.MergeFrom(from.network_providers_); + dll_.MergeFrom(from.dll_); + blacklisted_dll_.MergeFrom(from.blacklisted_dll_); + module_state_.MergeFrom(from.module_state_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.version_); + } + if (cached_has_bits & 0x00000002u) { + uptime_msec_ = from.uptime_msec_; + } + if (cached_has_bits & 0x00000004u) { + chrome_update_channel_ = from.chrome_update_channel_; + } + if (cached_has_bits & 0x00000008u) { + metrics_consent_ = from.metrics_consent_; + } + if (cached_has_bits & 0x00000010u) { + obsolete_extended_consent_ = from.obsolete_extended_consent_; + } + if (cached_has_bits & 0x00000020u) { + obsolete_field_trial_participant_ = from.obsolete_field_trial_participant_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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(dll_)) return false; + return true; +} + +void ClientIncidentReport_EnvironmentData_Process::InternalSwap(ClientIncidentReport_EnvironmentData_Process* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + obsolete_dlls_.InternalSwap(&other->obsolete_dlls_); + patches_.InternalSwap(&other->patches_); + network_providers_.InternalSwap(&other->network_providers_); + dll_.InternalSwap(&other->dll_); + blacklisted_dll_.InternalSwap(&other->blacklisted_dll_); + module_state_.InternalSwap(&other->module_state_); + version_.Swap(&other->version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(uptime_msec_, other->uptime_msec_); + swap(chrome_update_channel_, other->chrome_update_channel_); + swap(metrics_consent_, other->metrics_consent_); + swap(obsolete_extended_consent_, other->obsolete_extended_consent_); + swap(obsolete_field_trial_participant_, other->obsolete_field_trial_participant_); +} + +std::string ClientIncidentReport_EnvironmentData_Process::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Process"; +} + + +// =================================================================== + +void ClientIncidentReport_EnvironmentData::InitAsDefaultInstance() { + ::safe_browsing::_ClientIncidentReport_EnvironmentData_default_instance_._instance.get_mutable()->os_ = const_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS*>( + ::safe_browsing::ClientIncidentReport_EnvironmentData_OS::internal_default_instance()); + ::safe_browsing::_ClientIncidentReport_EnvironmentData_default_instance_._instance.get_mutable()->machine_ = const_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine*>( + ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine::internal_default_instance()); + ::safe_browsing::_ClientIncidentReport_EnvironmentData_default_instance_._instance.get_mutable()->process_ = const_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process*>( + ::safe_browsing::ClientIncidentReport_EnvironmentData_Process::internal_default_instance()); +} +class ClientIncidentReport_EnvironmentData::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_EnvironmentData>()._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->os_; +} +const ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine& +ClientIncidentReport_EnvironmentData::_Internal::machine(const ClientIncidentReport_EnvironmentData* msg) { + return *msg->machine_; +} +const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process& +ClientIncidentReport_EnvironmentData::_Internal::process(const ClientIncidentReport_EnvironmentData* msg) { + return *msg->process_; +} +ClientIncidentReport_EnvironmentData::ClientIncidentReport_EnvironmentData() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData) +} +ClientIncidentReport_EnvironmentData::ClientIncidentReport_EnvironmentData(const ClientIncidentReport_EnvironmentData& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_os()) { + os_ = new ::safe_browsing::ClientIncidentReport_EnvironmentData_OS(*from.os_); + } else { + os_ = nullptr; + } + if (from._internal_has_machine()) { + machine_ = new ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine(*from.machine_); + } else { + machine_ = nullptr; + } + if (from._internal_has_process()) { + process_ = new ::safe_browsing::ClientIncidentReport_EnvironmentData_Process(*from.process_); + } else { + process_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData) +} + +void ClientIncidentReport_EnvironmentData::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_EnvironmentData_csd_2eproto.base); + ::memset(&os_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&process_) - + reinterpret_cast<char*>(&os_)) + sizeof(process_)); +} + +ClientIncidentReport_EnvironmentData::~ClientIncidentReport_EnvironmentData() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData) + SharedDtor(); +} + +void ClientIncidentReport_EnvironmentData::SharedDtor() { + if (this != internal_default_instance()) delete os_; + if (this != internal_default_instance()) delete machine_; + if (this != internal_default_instance()) delete process_; +} + +void ClientIncidentReport_EnvironmentData::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_EnvironmentData& ClientIncidentReport_EnvironmentData::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_EnvironmentData_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_EnvironmentData::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.EnvironmentData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(os_ != nullptr); + os_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(machine_ != nullptr); + machine_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(process_ != nullptr); + process_->Clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_EnvironmentData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional .safe_browsing.ClientIncidentReport.EnvironmentData.OS os = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_process(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_EnvironmentData::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.EnvironmentData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .safe_browsing.ClientIncidentReport.EnvironmentData.OS os = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::os(this), target, stream); + } + + // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Machine machine = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::machine(this), target, stream); + } + + // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process process = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::process(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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( + *os_); + } + + // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Machine machine = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *machine_); + } + + // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process process = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *process_); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_EnvironmentData::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_EnvironmentData*>( + &from)); +} + +void ClientIncidentReport_EnvironmentData::MergeFrom(const ClientIncidentReport_EnvironmentData& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.EnvironmentData) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_os()->::safe_browsing::ClientIncidentReport_EnvironmentData_OS::MergeFrom(from._internal_os()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_machine()->::safe_browsing::ClientIncidentReport_EnvironmentData_Machine::MergeFrom(from._internal_machine()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_process()->::safe_browsing::ClientIncidentReport_EnvironmentData_Process::MergeFrom(from._internal_process()); + } + } +} + +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 (!process_->IsInitialized()) return false; + } + return true; +} + +void ClientIncidentReport_EnvironmentData::InternalSwap(ClientIncidentReport_EnvironmentData* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(os_, other->os_); + swap(machine_, other->machine_); + swap(process_, other->process_); +} + +std::string ClientIncidentReport_EnvironmentData::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.EnvironmentData"; +} + + +// =================================================================== + +void ClientIncidentReport_ExtensionData_ExtensionInfo::InitAsDefaultInstance() { +} +class ClientIncidentReport_ExtensionData_ExtensionInfo::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_ExtensionData_ExtensionInfo>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo) +} +ClientIncidentReport_ExtensionData_ExtensionInfo::ClientIncidentReport_ExtensionData_ExtensionInfo(const ClientIncidentReport_ExtensionData_ExtensionInfo& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_id()) { + id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.id_); + } + version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_version()) { + version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.version_); + } + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + description_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_description()) { + description_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.description_); + } + update_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_update_url()) { + update_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.update_url_); + } + manifest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_manifest()) { + manifest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.manifest_); + } + ::memcpy(&state_, &from.state_, + static_cast<size_t>(reinterpret_cast<char*>(&manifest_location_type_) - + reinterpret_cast<char*>(&state_)) + sizeof(manifest_location_type_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo) +} + +void ClientIncidentReport_ExtensionData_ExtensionInfo::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_ExtensionData_ExtensionInfo_csd_2eproto.base); + id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + description_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + update_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + manifest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&state_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&manifest_location_type_) - + reinterpret_cast<char*>(&state_)) + sizeof(manifest_location_type_)); +} + +ClientIncidentReport_ExtensionData_ExtensionInfo::~ClientIncidentReport_ExtensionData_ExtensionInfo() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo) + SharedDtor(); +} + +void ClientIncidentReport_ExtensionData_ExtensionInfo::SharedDtor() { + id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + description_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + update_url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + manifest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientIncidentReport_ExtensionData_ExtensionInfo::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_ExtensionData_ExtensionInfo& ClientIncidentReport_ExtensionData_ExtensionInfo::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_ExtensionData_ExtensionInfo_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_ExtensionData_ExtensionInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + id_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + version_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + name_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000008u) { + description_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000010u) { + update_url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000020u) { + manifest_.ClearNonDefaultToEmptyNoArena(); + } + } + if (cached_has_bits & 0x000000c0u) { + ::memset(&state_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&type_) - + reinterpret_cast<char*>(&state_)) + sizeof(type_)); + } + if (cached_has_bits & 0x0000ff00u) { + ::memset(&has_signature_validation_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&converted_from_user_script_) - + reinterpret_cast<char*>(&has_signature_validation_)) + sizeof(converted_from_user_script_)); + } + if (cached_has_bits & 0x00070000u) { + ::memset(&install_time_msec_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&manifest_location_type_) - + reinterpret_cast<char*>(&install_time_msec_)) + sizeof(manifest_location_type_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_ExtensionData_ExtensionInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_id(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string version = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_version(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string description = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_description(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + _Internal::set_has_type(&has_bits); + type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string update_url = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + auto str = _internal_mutable_update_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + _Internal::set_has_has_signature_validation(&has_bits); + has_signature_validation_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool signature_is_valid = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) { + _Internal::set_has_signature_is_valid(&has_bits); + signature_is_valid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool installed_by_custodian = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) { + _Internal::set_has_installed_by_custodian(&has_bits); + installed_by_custodian_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool installed_by_default = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) { + _Internal::set_has_installed_by_default(&has_bits); + installed_by_default_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool installed_by_oem = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) { + _Internal::set_has_installed_by_oem(&has_bits); + installed_by_oem_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool from_bookmark = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 104)) { + _Internal::set_has_from_bookmark(&has_bits); + from_bookmark_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool from_webstore = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) { + _Internal::set_has_from_webstore(&has_bits); + from_webstore_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool converted_from_user_script = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 120)) { + _Internal::set_has_converted_from_user_script(&has_bits); + converted_from_user_script_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool may_be_untrusted = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 128)) { + _Internal::set_has_may_be_untrusted(&has_bits); + may_be_untrusted_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional int64 install_time_msec = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 136)) { + _Internal::set_has_install_time_msec(&has_bits); + install_time_msec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional int32 manifest_location_type = 18; + case 18: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) { + _Internal::set_has_manifest_location_type(&has_bits); + manifest_location_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string manifest = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { + auto str = _internal_mutable_manifest(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_ExtensionData_ExtensionInfo::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 5, this->_internal_state(), target); + } + + // optional int32 type = 6; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(12, this->_internal_installed_by_oem(), target); + } + + // optional bool from_bookmark = 13; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(13, this->_internal_from_bookmark(), target); + } + + // optional bool from_webstore = 14; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_state()); + } + + // optional int32 type = 6; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + 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 + + ::PROTOBUF_NAMESPACE_ID::internal::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 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_manifest_location_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_ExtensionData_ExtensionInfo::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_ExtensionData_ExtensionInfo*>( + &from)); +} + +void ClientIncidentReport_ExtensionData_ExtensionInfo::MergeFrom(const ClientIncidentReport_ExtensionData_ExtensionInfo& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + id_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.id_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.version_); + } + if (cached_has_bits & 0x00000004u) { + _has_bits_[0] |= 0x00000004u; + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (cached_has_bits & 0x00000008u) { + _has_bits_[0] |= 0x00000008u; + description_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.description_); + } + if (cached_has_bits & 0x00000010u) { + _has_bits_[0] |= 0x00000010u; + update_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.update_url_); + } + if (cached_has_bits & 0x00000020u) { + _has_bits_[0] |= 0x00000020u; + manifest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.manifest_); + } + if (cached_has_bits & 0x00000040u) { + state_ = from.state_; + } + if (cached_has_bits & 0x00000080u) { + type_ = from.type_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + has_signature_validation_ = from.has_signature_validation_; + } + if (cached_has_bits & 0x00000200u) { + signature_is_valid_ = from.signature_is_valid_; + } + if (cached_has_bits & 0x00000400u) { + installed_by_custodian_ = from.installed_by_custodian_; + } + if (cached_has_bits & 0x00000800u) { + installed_by_default_ = from.installed_by_default_; + } + if (cached_has_bits & 0x00001000u) { + installed_by_oem_ = from.installed_by_oem_; + } + if (cached_has_bits & 0x00002000u) { + from_bookmark_ = from.from_bookmark_; + } + if (cached_has_bits & 0x00004000u) { + from_webstore_ = from.from_webstore_; + } + if (cached_has_bits & 0x00008000u) { + converted_from_user_script_ = from.converted_from_user_script_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00070000u) { + if (cached_has_bits & 0x00010000u) { + install_time_msec_ = from.install_time_msec_; + } + if (cached_has_bits & 0x00020000u) { + may_be_untrusted_ = from.may_be_untrusted_; + } + if (cached_has_bits & 0x00040000u) { + manifest_location_type_ = from.manifest_location_type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + id_.Swap(&other->id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + version_.Swap(&other->version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + description_.Swap(&other->description_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + update_url_.Swap(&other->update_url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + manifest_.Swap(&other->manifest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(state_, other->state_); + swap(type_, other->type_); + swap(has_signature_validation_, other->has_signature_validation_); + swap(signature_is_valid_, other->signature_is_valid_); + swap(installed_by_custodian_, other->installed_by_custodian_); + swap(installed_by_default_, other->installed_by_default_); + swap(installed_by_oem_, other->installed_by_oem_); + swap(from_bookmark_, other->from_bookmark_); + swap(from_webstore_, other->from_webstore_); + swap(converted_from_user_script_, other->converted_from_user_script_); + swap(install_time_msec_, other->install_time_msec_); + swap(may_be_untrusted_, other->may_be_untrusted_); + swap(manifest_location_type_, other->manifest_location_type_); +} + +std::string ClientIncidentReport_ExtensionData_ExtensionInfo::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo"; +} + + +// =================================================================== + +void ClientIncidentReport_ExtensionData::InitAsDefaultInstance() { + ::safe_browsing::_ClientIncidentReport_ExtensionData_default_instance_._instance.get_mutable()->last_installed_extension_ = const_cast< ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo*>( + ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo::internal_default_instance()); +} +class ClientIncidentReport_ExtensionData::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_ExtensionData>()._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->last_installed_extension_; +} +ClientIncidentReport_ExtensionData::ClientIncidentReport_ExtensionData() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.ExtensionData) +} +ClientIncidentReport_ExtensionData::ClientIncidentReport_ExtensionData(const ClientIncidentReport_ExtensionData& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_last_installed_extension()) { + last_installed_extension_ = new ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo(*from.last_installed_extension_); + } else { + last_installed_extension_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.ExtensionData) +} + +void ClientIncidentReport_ExtensionData::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_ExtensionData_csd_2eproto.base); + last_installed_extension_ = nullptr; +} + +ClientIncidentReport_ExtensionData::~ClientIncidentReport_ExtensionData() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.ExtensionData) + SharedDtor(); +} + +void ClientIncidentReport_ExtensionData::SharedDtor() { + if (this != internal_default_instance()) delete last_installed_extension_; +} + +void ClientIncidentReport_ExtensionData::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_ExtensionData& ClientIncidentReport_ExtensionData::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_ExtensionData_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_ExtensionData::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.ExtensionData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(last_installed_extension_ != nullptr); + last_installed_extension_->Clear(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_ExtensionData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo last_installed_extension = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_last_installed_extension(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_ExtensionData::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.ExtensionData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo last_installed_extension = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::last_installed_extension(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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 = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *last_installed_extension_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_ExtensionData::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_ExtensionData*>( + &from)); +} + +void ClientIncidentReport_ExtensionData::MergeFrom(const ClientIncidentReport_ExtensionData& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.ExtensionData) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_last_installed_extension()) { + _internal_mutable_last_installed_extension()->::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo::MergeFrom(from._internal_last_installed_extension()); + } +} + +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_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(last_installed_extension_, other->last_installed_extension_); +} + +std::string ClientIncidentReport_ExtensionData::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.ExtensionData"; +} + + +// =================================================================== + +void ClientIncidentReport_NonBinaryDownloadDetails::InitAsDefaultInstance() { +} +class ClientIncidentReport_NonBinaryDownloadDetails::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport_NonBinaryDownloadDetails>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails) +} +ClientIncidentReport_NonBinaryDownloadDetails::ClientIncidentReport_NonBinaryDownloadDetails(const ClientIncidentReport_NonBinaryDownloadDetails& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + file_type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_file_type()) { + file_type_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.file_type_); + } + url_spec_sha256_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_url_spec_sha256()) { + url_spec_sha256_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_spec_sha256_); + } + host_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_host()) { + host_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.host_); + } + length_ = from.length_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails) +} + +void ClientIncidentReport_NonBinaryDownloadDetails::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_NonBinaryDownloadDetails_csd_2eproto.base); + file_type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + url_spec_sha256_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + host_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + length_ = PROTOBUF_LONGLONG(0); +} + +ClientIncidentReport_NonBinaryDownloadDetails::~ClientIncidentReport_NonBinaryDownloadDetails() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails) + SharedDtor(); +} + +void ClientIncidentReport_NonBinaryDownloadDetails::SharedDtor() { + file_type_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + url_spec_sha256_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + host_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientIncidentReport_NonBinaryDownloadDetails::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport_NonBinaryDownloadDetails& ClientIncidentReport_NonBinaryDownloadDetails::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_NonBinaryDownloadDetails_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport_NonBinaryDownloadDetails::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + file_type_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + url_spec_sha256_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + host_.ClearNonDefaultToEmptyNoArena(); + } + } + length_ = PROTOBUF_LONGLONG(0); + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport_NonBinaryDownloadDetails::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string file_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_file_type(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_url_spec_sha256(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string host = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_host(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional int64 length = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + _Internal::set_has_length(&has_bits); + length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport_NonBinaryDownloadDetails::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_length(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_length()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport_NonBinaryDownloadDetails::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport_NonBinaryDownloadDetails*>( + &from)); +} + +void ClientIncidentReport_NonBinaryDownloadDetails::MergeFrom(const ClientIncidentReport_NonBinaryDownloadDetails& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + file_type_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.file_type_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + url_spec_sha256_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_spec_sha256_); + } + if (cached_has_bits & 0x00000004u) { + _has_bits_[0] |= 0x00000004u; + host_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.host_); + } + if (cached_has_bits & 0x00000008u) { + length_ = from.length_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + file_type_.Swap(&other->file_type_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + url_spec_sha256_.Swap(&other->url_spec_sha256_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + host_.Swap(&other->host_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(length_, other->length_); +} + +std::string ClientIncidentReport_NonBinaryDownloadDetails::GetTypeName() const { + return "safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails"; +} + + +// =================================================================== + +void ClientIncidentReport::InitAsDefaultInstance() { + ::safe_browsing::_ClientIncidentReport_default_instance_._instance.get_mutable()->download_ = const_cast< ::safe_browsing::ClientIncidentReport_DownloadDetails*>( + ::safe_browsing::ClientIncidentReport_DownloadDetails::internal_default_instance()); + ::safe_browsing::_ClientIncidentReport_default_instance_._instance.get_mutable()->environment_ = const_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData*>( + ::safe_browsing::ClientIncidentReport_EnvironmentData::internal_default_instance()); + ::safe_browsing::_ClientIncidentReport_default_instance_._instance.get_mutable()->population_ = const_cast< ::safe_browsing::ChromeUserPopulation*>( + ::safe_browsing::ChromeUserPopulation::internal_default_instance()); + ::safe_browsing::_ClientIncidentReport_default_instance_._instance.get_mutable()->extension_data_ = const_cast< ::safe_browsing::ClientIncidentReport_ExtensionData*>( + ::safe_browsing::ClientIncidentReport_ExtensionData::internal_default_instance()); + ::safe_browsing::_ClientIncidentReport_default_instance_._instance.get_mutable()->non_binary_download_ = const_cast< ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails*>( + ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails::internal_default_instance()); +} +class ClientIncidentReport::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentReport>()._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->download_; +} +const ::safe_browsing::ClientIncidentReport_EnvironmentData& +ClientIncidentReport::_Internal::environment(const ClientIncidentReport* msg) { + return *msg->environment_; +} +const ::safe_browsing::ChromeUserPopulation& +ClientIncidentReport::_Internal::population(const ClientIncidentReport* msg) { + return *msg->population_; +} +const ::safe_browsing::ClientIncidentReport_ExtensionData& +ClientIncidentReport::_Internal::extension_data(const ClientIncidentReport* msg) { + return *msg->extension_data_; +} +const ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails& +ClientIncidentReport::_Internal::non_binary_download(const ClientIncidentReport* msg) { + return *msg->non_binary_download_; +} +ClientIncidentReport::ClientIncidentReport() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport) +} +ClientIncidentReport::ClientIncidentReport(const ClientIncidentReport& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + incident_(from.incident_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_download()) { + download_ = new ::safe_browsing::ClientIncidentReport_DownloadDetails(*from.download_); + } else { + download_ = nullptr; + } + if (from._internal_has_environment()) { + environment_ = new ::safe_browsing::ClientIncidentReport_EnvironmentData(*from.environment_); + } else { + environment_ = nullptr; + } + if (from._internal_has_population()) { + population_ = new ::safe_browsing::ChromeUserPopulation(*from.population_); + } else { + population_ = nullptr; + } + if (from._internal_has_extension_data()) { + extension_data_ = new ::safe_browsing::ClientIncidentReport_ExtensionData(*from.extension_data_); + } else { + extension_data_ = nullptr; + } + if (from._internal_has_non_binary_download()) { + non_binary_download_ = new ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails(*from.non_binary_download_); + } else { + non_binary_download_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport) +} + +void ClientIncidentReport::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentReport_csd_2eproto.base); + ::memset(&download_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&non_binary_download_) - + reinterpret_cast<char*>(&download_)) + sizeof(non_binary_download_)); +} + +ClientIncidentReport::~ClientIncidentReport() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport) + SharedDtor(); +} + +void ClientIncidentReport::SharedDtor() { + if (this != internal_default_instance()) delete download_; + if (this != internal_default_instance()) delete environment_; + if (this != internal_default_instance()) delete population_; + if (this != internal_default_instance()) delete extension_data_; + if (this != internal_default_instance()) delete non_binary_download_; +} + +void ClientIncidentReport::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentReport& ClientIncidentReport::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentReport_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentReport::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentReport) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + incident_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(download_ != nullptr); + download_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(environment_ != nullptr); + environment_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(population_ != nullptr); + population_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(extension_data_ != nullptr); + extension_data_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(non_binary_download_ != nullptr); + non_binary_download_->Clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentReport::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // repeated .safe_browsing.ClientIncidentReport.IncidentData incident = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_non_binary_download(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentReport::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentReport) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .safe_browsing.ClientIncidentReport.IncidentData incident = 1; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_incident_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_incident(i), target, stream); + } + + cached_has_bits = _has_bits_[0]; + // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::download(this), target, stream); + } + + // optional .safe_browsing.ClientIncidentReport.EnvironmentData environment = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::environment(this), target, stream); + } + + // optional .safe_browsing.ChromeUserPopulation population = 7; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::population(this), target, stream); + } + + // optional .safe_browsing.ClientIncidentReport.ExtensionData extension_data = 8; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 8, _Internal::extension_data(this), target, stream); + } + + // optional .safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails non_binary_download = 9; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 9, _Internal::non_binary_download(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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->incident_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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( + *download_); + } + + // optional .safe_browsing.ClientIncidentReport.EnvironmentData environment = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *environment_); + } + + // optional .safe_browsing.ChromeUserPopulation population = 7; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *population_); + } + + // optional .safe_browsing.ClientIncidentReport.ExtensionData extension_data = 8; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *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( + *non_binary_download_); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentReport::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentReport*>( + &from)); +} + +void ClientIncidentReport::MergeFrom(const ClientIncidentReport& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentReport) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + incident_.MergeFrom(from.incident_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_download()->::safe_browsing::ClientIncidentReport_DownloadDetails::MergeFrom(from._internal_download()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_environment()->::safe_browsing::ClientIncidentReport_EnvironmentData::MergeFrom(from._internal_environment()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(from._internal_population()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_extension_data()->::safe_browsing::ClientIncidentReport_ExtensionData::MergeFrom(from._internal_extension_data()); + } + if (cached_has_bits & 0x00000010u) { + _internal_mutable_non_binary_download()->::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails::MergeFrom(from._internal_non_binary_download()); + } + } +} + +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(incident_)) return false; + if (_internal_has_download()) { + if (!download_->IsInitialized()) return false; + } + if (_internal_has_environment()) { + if (!environment_->IsInitialized()) return false; + } + return true; +} + +void ClientIncidentReport::InternalSwap(ClientIncidentReport* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + incident_.InternalSwap(&other->incident_); + swap(download_, other->download_); + swap(environment_, other->environment_); + swap(population_, other->population_); + swap(extension_data_, other->extension_data_); + swap(non_binary_download_, other->non_binary_download_); +} + +std::string ClientIncidentReport::GetTypeName() const { + return "safe_browsing.ClientIncidentReport"; +} + + +// =================================================================== + +void ClientIncidentResponse_EnvironmentRequest::InitAsDefaultInstance() { +} +class ClientIncidentResponse_EnvironmentRequest::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentResponse_EnvironmentRequest>()._has_bits_); + static void set_has_dll_index(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +ClientIncidentResponse_EnvironmentRequest::ClientIncidentResponse_EnvironmentRequest() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentResponse.EnvironmentRequest) +} +ClientIncidentResponse_EnvironmentRequest::ClientIncidentResponse_EnvironmentRequest(const ClientIncidentResponse_EnvironmentRequest& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + dll_index_ = from.dll_index_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentResponse.EnvironmentRequest) +} + +void ClientIncidentResponse_EnvironmentRequest::SharedCtor() { + dll_index_ = 0; +} + +ClientIncidentResponse_EnvironmentRequest::~ClientIncidentResponse_EnvironmentRequest() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentResponse.EnvironmentRequest) + SharedDtor(); +} + +void ClientIncidentResponse_EnvironmentRequest::SharedDtor() { +} + +void ClientIncidentResponse_EnvironmentRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentResponse_EnvironmentRequest& ClientIncidentResponse_EnvironmentRequest::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentResponse_EnvironmentRequest_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentResponse_EnvironmentRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentResponse.EnvironmentRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + dll_index_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentResponse_EnvironmentRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional int32 dll_index = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_dll_index(&has_bits); + dll_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentResponse_EnvironmentRequest::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentResponse.EnvironmentRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 dll_index = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_dll_index(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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 = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_dll_index()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentResponse_EnvironmentRequest::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentResponse_EnvironmentRequest*>( + &from)); +} + +void ClientIncidentResponse_EnvironmentRequest::MergeFrom(const ClientIncidentResponse_EnvironmentRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentResponse.EnvironmentRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_dll_index()) { + _internal_set_dll_index(from._internal_dll_index()); + } +} + +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_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(dll_index_, other->dll_index_); +} + +std::string ClientIncidentResponse_EnvironmentRequest::GetTypeName() const { + return "safe_browsing.ClientIncidentResponse.EnvironmentRequest"; +} + + +// =================================================================== + +void ClientIncidentResponse::InitAsDefaultInstance() { +} +class ClientIncidentResponse::_Internal { + public: + using HasBits = decltype(std::declval<ClientIncidentResponse>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentResponse) +} +ClientIncidentResponse::ClientIncidentResponse(const ClientIncidentResponse& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + environment_requests_(from.environment_requests_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_token()) { + token_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.token_); + } + download_requested_ = from.download_requested_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentResponse) +} + +void ClientIncidentResponse::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientIncidentResponse_csd_2eproto.base); + token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + download_requested_ = false; +} + +ClientIncidentResponse::~ClientIncidentResponse() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentResponse) + SharedDtor(); +} + +void ClientIncidentResponse::SharedDtor() { + token_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientIncidentResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientIncidentResponse& ClientIncidentResponse::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientIncidentResponse_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientIncidentResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientIncidentResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + environment_requests_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + token_.ClearNonDefaultToEmptyNoArena(); + } + download_requested_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientIncidentResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional bytes token = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_token(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool download_requested = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_download_requested(&has_bits); + download_requested_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .safe_browsing.ClientIncidentResponse.EnvironmentRequest environment_requests = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientIncidentResponse::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientIncidentResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_download_requested(), target); + } + + // repeated .safe_browsing.ClientIncidentResponse.EnvironmentRequest environment_requests = 3; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_environment_requests_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_environment_requests(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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->environment_requests_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientIncidentResponse::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientIncidentResponse*>( + &from)); +} + +void ClientIncidentResponse::MergeFrom(const ClientIncidentResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientIncidentResponse) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + environment_requests_.MergeFrom(from.environment_requests_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + token_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.token_); + } + if (cached_has_bits & 0x00000002u) { + download_requested_ = from.download_requested_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + environment_requests_.InternalSwap(&other->environment_requests_); + token_.Swap(&other->token_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(download_requested_, other->download_requested_); +} + +std::string ClientIncidentResponse::GetTypeName() const { + return "safe_browsing.ClientIncidentResponse"; +} + + +// =================================================================== + +void DownloadMetadata::InitAsDefaultInstance() { + ::safe_browsing::_DownloadMetadata_default_instance_._instance.get_mutable()->download_ = const_cast< ::safe_browsing::ClientIncidentReport_DownloadDetails*>( + ::safe_browsing::ClientIncidentReport_DownloadDetails::internal_default_instance()); +} +class DownloadMetadata::_Internal { + public: + using HasBits = decltype(std::declval<DownloadMetadata>()._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->download_; +} +DownloadMetadata::DownloadMetadata() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.DownloadMetadata) +} +DownloadMetadata::DownloadMetadata(const DownloadMetadata& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_download()) { + download_ = new ::safe_browsing::ClientIncidentReport_DownloadDetails(*from.download_); + } else { + download_ = nullptr; + } + download_id_ = from.download_id_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.DownloadMetadata) +} + +void DownloadMetadata::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DownloadMetadata_csd_2eproto.base); + ::memset(&download_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&download_id_) - + reinterpret_cast<char*>(&download_)) + sizeof(download_id_)); +} + +DownloadMetadata::~DownloadMetadata() { + // @@protoc_insertion_point(destructor:safe_browsing.DownloadMetadata) + SharedDtor(); +} + +void DownloadMetadata::SharedDtor() { + if (this != internal_default_instance()) delete download_; +} + +void DownloadMetadata::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const DownloadMetadata& DownloadMetadata::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_DownloadMetadata_csd_2eproto.base); + return *internal_default_instance(); +} + + +void DownloadMetadata::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.DownloadMetadata) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(download_ != nullptr); + download_->Clear(); + } + download_id_ = 0u; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* DownloadMetadata::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional uint32 download_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_download_id(&has_bits); + download_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_download(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DownloadMetadata::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.DownloadMetadata) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional uint32 download_id = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_download_id(), target); + } + + // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::download(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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( + *download_); + } + + // optional uint32 download_id = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_download_id()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DownloadMetadata::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const DownloadMetadata*>( + &from)); +} + +void DownloadMetadata::MergeFrom(const DownloadMetadata& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.DownloadMetadata) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_download()->::safe_browsing::ClientIncidentReport_DownloadDetails::MergeFrom(from._internal_download()); + } + if (cached_has_bits & 0x00000002u) { + download_id_ = from.download_id_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 (!download_->IsInitialized()) return false; + } + return true; +} + +void DownloadMetadata::InternalSwap(DownloadMetadata* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(download_, other->download_); + swap(download_id_, other->download_id_); +} + +std::string DownloadMetadata::GetTypeName() const { + return "safe_browsing.DownloadMetadata"; +} + + +// =================================================================== + +void ClientSafeBrowsingReportRequest_HTTPHeader::InitAsDefaultInstance() { +} +class ClientSafeBrowsingReportRequest_HTTPHeader::_Internal { + public: + using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_HTTPHeader>()._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; + } +}; + +ClientSafeBrowsingReportRequest_HTTPHeader::ClientSafeBrowsingReportRequest_HTTPHeader() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader) +} +ClientSafeBrowsingReportRequest_HTTPHeader::ClientSafeBrowsingReportRequest_HTTPHeader(const ClientSafeBrowsingReportRequest_HTTPHeader& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_value()) { + value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader) +} + +void ClientSafeBrowsingReportRequest_HTTPHeader::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientSafeBrowsingReportRequest_HTTPHeader_csd_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ClientSafeBrowsingReportRequest_HTTPHeader::~ClientSafeBrowsingReportRequest_HTTPHeader() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader) + SharedDtor(); +} + +void ClientSafeBrowsingReportRequest_HTTPHeader::SharedDtor() { + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientSafeBrowsingReportRequest_HTTPHeader::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientSafeBrowsingReportRequest_HTTPHeader& ClientSafeBrowsingReportRequest_HTTPHeader::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientSafeBrowsingReportRequest_HTTPHeader_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientSafeBrowsingReportRequest_HTTPHeader::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + value_.ClearNonDefaultToEmptyNoArena(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientSafeBrowsingReportRequest_HTTPHeader::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required bytes name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_value(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientSafeBrowsingReportRequest_HTTPHeader::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bytes value = 2; + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientSafeBrowsingReportRequest_HTTPHeader::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientSafeBrowsingReportRequest_HTTPHeader*>( + &from)); +} + +void ClientSafeBrowsingReportRequest_HTTPHeader::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPHeader& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_); + } + } +} + +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 ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + return true; +} + +void ClientSafeBrowsingReportRequest_HTTPHeader::InternalSwap(ClientSafeBrowsingReportRequest_HTTPHeader* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string ClientSafeBrowsingReportRequest_HTTPHeader::GetTypeName() const { + return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader"; +} + + +// =================================================================== + +void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::InitAsDefaultInstance() { +} +class ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_Internal { + public: + using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine) +} +ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + verb_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_verb()) { + verb_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.verb_); + } + uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_uri()) { + uri_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.uri_); + } + version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_version()) { + version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.version_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine) +} + +void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_csd_2eproto.base); + verb_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::~ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine) + SharedDtor(); +} + +void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::SharedDtor() { + verb_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + verb_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + uri_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + version_.ClearNonDefaultToEmptyNoArena(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional bytes verb = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_verb(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes uri = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_uri(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes version = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_version(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine*>( + &from)); +} + +void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + verb_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.verb_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + uri_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.uri_); + } + if (cached_has_bits & 0x00000004u) { + _has_bits_[0] |= 0x00000004u; + version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.version_); + } + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + verb_.Swap(&other->verb_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + uri_.Swap(&other->uri_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + version_.Swap(&other->version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::GetTypeName() const { + return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine"; +} + + +// =================================================================== + +void ClientSafeBrowsingReportRequest_HTTPRequest::InitAsDefaultInstance() { + ::safe_browsing::_ClientSafeBrowsingReportRequest_HTTPRequest_default_instance_._instance.get_mutable()->firstline_ = const_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine*>( + ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::internal_default_instance()); +} +class ClientSafeBrowsingReportRequest_HTTPRequest::_Internal { + public: + using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_HTTPRequest>()._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->firstline_; +} +ClientSafeBrowsingReportRequest_HTTPRequest::ClientSafeBrowsingReportRequest_HTTPRequest() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest) +} +ClientSafeBrowsingReportRequest_HTTPRequest::ClientSafeBrowsingReportRequest_HTTPRequest(const ClientSafeBrowsingReportRequest_HTTPRequest& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + headers_(from.headers_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_body()) { + body_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.body_); + } + bodydigest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_bodydigest()) { + bodydigest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bodydigest_); + } + if (from._internal_has_firstline()) { + firstline_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(*from.firstline_); + } else { + firstline_ = nullptr; + } + bodylength_ = from.bodylength_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest) +} + +void ClientSafeBrowsingReportRequest_HTTPRequest::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientSafeBrowsingReportRequest_HTTPRequest_csd_2eproto.base); + body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + bodydigest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&firstline_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&bodylength_) - + reinterpret_cast<char*>(&firstline_)) + sizeof(bodylength_)); +} + +ClientSafeBrowsingReportRequest_HTTPRequest::~ClientSafeBrowsingReportRequest_HTTPRequest() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest) + SharedDtor(); +} + +void ClientSafeBrowsingReportRequest_HTTPRequest::SharedDtor() { + body_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + bodydigest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete firstline_; +} + +void ClientSafeBrowsingReportRequest_HTTPRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientSafeBrowsingReportRequest_HTTPRequest& ClientSafeBrowsingReportRequest_HTTPRequest::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientSafeBrowsingReportRequest_HTTPRequest_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientSafeBrowsingReportRequest_HTTPRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + headers_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + body_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + bodydigest_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(firstline_ != nullptr); + firstline_->Clear(); + } + } + bodylength_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientSafeBrowsingReportRequest_HTTPRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine firstline = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_body(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes bodydigest = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_bodydigest(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional int32 bodylength = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_bodylength(&has_bits); + bodylength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientSafeBrowsingReportRequest_HTTPRequest::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine firstline = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::firstline(this), target, stream); + } + + // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_headers_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_headers(i), 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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_bodylength(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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->headers_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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( + *firstline_); + } + + // optional int32 bodylength = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_bodylength()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientSafeBrowsingReportRequest_HTTPRequest::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientSafeBrowsingReportRequest_HTTPRequest*>( + &from)); +} + +void ClientSafeBrowsingReportRequest_HTTPRequest::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + headers_.MergeFrom(from.headers_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + body_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.body_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + bodydigest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bodydigest_); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_firstline()->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::MergeFrom(from._internal_firstline()); + } + if (cached_has_bits & 0x00000008u) { + bodylength_ = from.bodylength_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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(headers_)) return false; + return true; +} + +void ClientSafeBrowsingReportRequest_HTTPRequest::InternalSwap(ClientSafeBrowsingReportRequest_HTTPRequest* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + headers_.InternalSwap(&other->headers_); + body_.Swap(&other->body_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + bodydigest_.Swap(&other->bodydigest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(firstline_, other->firstline_); + swap(bodylength_, other->bodylength_); +} + +std::string ClientSafeBrowsingReportRequest_HTTPRequest::GetTypeName() const { + return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest"; +} + + +// =================================================================== + +void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::InitAsDefaultInstance() { +} +class ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_Internal { + public: + using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine) +} +ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_message()) { + message_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.message_); + } + version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_version()) { + version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.version_); + } + code_ = from.code_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine) +} + +void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_csd_2eproto.base); + message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + code_ = 0; +} + +ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::~ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine) + SharedDtor(); +} + +void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::SharedDtor() { + message_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + message_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + version_.ClearNonDefaultToEmptyNoArena(); + } + } + code_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional int32 code = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_code(&has_bits); + code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes message = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_message(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes version = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_version(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 code = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_code()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine*>( + &from)); +} + +void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + message_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.message_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.version_); + } + if (cached_has_bits & 0x00000004u) { + code_ = from.code_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + message_.Swap(&other->message_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + version_.Swap(&other->version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(code_, other->code_); +} + +std::string ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::GetTypeName() const { + return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine"; +} + + +// =================================================================== + +void ClientSafeBrowsingReportRequest_HTTPResponse::InitAsDefaultInstance() { + ::safe_browsing::_ClientSafeBrowsingReportRequest_HTTPResponse_default_instance_._instance.get_mutable()->firstline_ = const_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine*>( + ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::internal_default_instance()); +} +class ClientSafeBrowsingReportRequest_HTTPResponse::_Internal { + public: + using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_HTTPResponse>()._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->firstline_; +} +ClientSafeBrowsingReportRequest_HTTPResponse::ClientSafeBrowsingReportRequest_HTTPResponse() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse) +} +ClientSafeBrowsingReportRequest_HTTPResponse::ClientSafeBrowsingReportRequest_HTTPResponse(const ClientSafeBrowsingReportRequest_HTTPResponse& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + headers_(from.headers_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_body()) { + body_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.body_); + } + bodydigest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_bodydigest()) { + bodydigest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bodydigest_); + } + remote_ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_remote_ip()) { + remote_ip_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.remote_ip_); + } + if (from._internal_has_firstline()) { + firstline_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(*from.firstline_); + } else { + firstline_ = nullptr; + } + bodylength_ = from.bodylength_; + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse) +} + +void ClientSafeBrowsingReportRequest_HTTPResponse::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientSafeBrowsingReportRequest_HTTPResponse_csd_2eproto.base); + body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + bodydigest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + remote_ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&firstline_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&bodylength_) - + reinterpret_cast<char*>(&firstline_)) + sizeof(bodylength_)); +} + +ClientSafeBrowsingReportRequest_HTTPResponse::~ClientSafeBrowsingReportRequest_HTTPResponse() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse) + SharedDtor(); +} + +void ClientSafeBrowsingReportRequest_HTTPResponse::SharedDtor() { + body_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + bodydigest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + remote_ip_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete firstline_; +} + +void ClientSafeBrowsingReportRequest_HTTPResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientSafeBrowsingReportRequest_HTTPResponse& ClientSafeBrowsingReportRequest_HTTPResponse::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientSafeBrowsingReportRequest_HTTPResponse_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientSafeBrowsingReportRequest_HTTPResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + headers_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + body_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + bodydigest_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + remote_ip_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(firstline_ != nullptr); + firstline_->Clear(); + } + } + bodylength_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientSafeBrowsingReportRequest_HTTPResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine firstline = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_body(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes bodydigest = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_bodydigest(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional int32 bodylength = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_bodylength(&has_bits); + bodylength_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bytes remote_ip = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + auto str = _internal_mutable_remote_ip(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientSafeBrowsingReportRequest_HTTPResponse::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine firstline = 1; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::firstline(this), target, stream); + } + + // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_headers_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_headers(i), 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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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->headers_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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( + *firstline_); + } + + // optional int32 bodylength = 5; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_bodylength()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientSafeBrowsingReportRequest_HTTPResponse::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientSafeBrowsingReportRequest_HTTPResponse*>( + &from)); +} + +void ClientSafeBrowsingReportRequest_HTTPResponse::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + headers_.MergeFrom(from.headers_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + body_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.body_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + bodydigest_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.bodydigest_); + } + if (cached_has_bits & 0x00000004u) { + _has_bits_[0] |= 0x00000004u; + remote_ip_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.remote_ip_); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_firstline()->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::MergeFrom(from._internal_firstline()); + } + if (cached_has_bits & 0x00000010u) { + bodylength_ = from.bodylength_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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(headers_)) return false; + return true; +} + +void ClientSafeBrowsingReportRequest_HTTPResponse::InternalSwap(ClientSafeBrowsingReportRequest_HTTPResponse* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + headers_.InternalSwap(&other->headers_); + body_.Swap(&other->body_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + bodydigest_.Swap(&other->bodydigest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + remote_ip_.Swap(&other->remote_ip_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(firstline_, other->firstline_); + swap(bodylength_, other->bodylength_); +} + +std::string ClientSafeBrowsingReportRequest_HTTPResponse::GetTypeName() const { + return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse"; +} + + +// =================================================================== + +void ClientSafeBrowsingReportRequest_Resource::InitAsDefaultInstance() { + ::safe_browsing::_ClientSafeBrowsingReportRequest_Resource_default_instance_._instance.get_mutable()->request_ = const_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest*>( + ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest::internal_default_instance()); + ::safe_browsing::_ClientSafeBrowsingReportRequest_Resource_default_instance_._instance.get_mutable()->response_ = const_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse*>( + ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse::internal_default_instance()); +} +class ClientSafeBrowsingReportRequest_Resource::_Internal { + public: + using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_Resource>()._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; + } +}; + +const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest& +ClientSafeBrowsingReportRequest_Resource::_Internal::request(const ClientSafeBrowsingReportRequest_Resource* msg) { + return *msg->request_; +} +const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse& +ClientSafeBrowsingReportRequest_Resource::_Internal::response(const ClientSafeBrowsingReportRequest_Resource* msg) { + return *msg->response_; +} +ClientSafeBrowsingReportRequest_Resource::ClientSafeBrowsingReportRequest_Resource() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest.Resource) +} +ClientSafeBrowsingReportRequest_Resource::ClientSafeBrowsingReportRequest_Resource(const ClientSafeBrowsingReportRequest_Resource& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + child_ids_(from.child_ids_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_url()) { + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + tag_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_tag_name()) { + tag_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.tag_name_); + } + if (from._internal_has_request()) { + request_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest(*from.request_); + } else { + request_ = nullptr; + } + if (from._internal_has_response()) { + response_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse(*from.response_); + } else { + response_ = nullptr; + } + ::memcpy(&id_, &from.id_, + static_cast<size_t>(reinterpret_cast<char*>(&parent_id_) - + reinterpret_cast<char*>(&id_)) + sizeof(parent_id_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.Resource) +} + +void ClientSafeBrowsingReportRequest_Resource::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientSafeBrowsingReportRequest_Resource_csd_2eproto.base); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + tag_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&request_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&parent_id_) - + reinterpret_cast<char*>(&request_)) + sizeof(parent_id_)); +} + +ClientSafeBrowsingReportRequest_Resource::~ClientSafeBrowsingReportRequest_Resource() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.Resource) + SharedDtor(); +} + +void ClientSafeBrowsingReportRequest_Resource::SharedDtor() { + url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + tag_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete request_; + if (this != internal_default_instance()) delete response_; +} + +void ClientSafeBrowsingReportRequest_Resource::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientSafeBrowsingReportRequest_Resource& ClientSafeBrowsingReportRequest_Resource::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientSafeBrowsingReportRequest_Resource_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientSafeBrowsingReportRequest_Resource::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.Resource) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + child_ids_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + tag_name_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(request_ != nullptr); + request_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(response_ != nullptr); + response_->Clear(); + } + } + if (cached_has_bits & 0x00000030u) { + ::memset(&id_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&parent_id_) - + reinterpret_cast<char*>(&id_)) + sizeof(parent_id_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientSafeBrowsingReportRequest_Resource::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // required int32 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_id(&has_bits); + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string url = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_parent_id(&has_bits); + parent_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int32 child_ids = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_child_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<48>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + auto str = _internal_mutable_tag_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientSafeBrowsingReportRequest_Resource::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.Resource) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // required int32 id = 1; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::request(this), target, stream); + } + + // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse response = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::response(this), target, stream); + } + + // optional int32 parent_id = 5; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_id()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->child_ids_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_child_ids_size()); + total_size += data_size; + } + + cached_has_bits = _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( + *request_); + } + + // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse response = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *response_); + } + + } + // optional int32 parent_id = 5; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_parent_id()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientSafeBrowsingReportRequest_Resource::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientSafeBrowsingReportRequest_Resource*>( + &from)); +} + +void ClientSafeBrowsingReportRequest_Resource::MergeFrom(const ClientSafeBrowsingReportRequest_Resource& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.Resource) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + child_ids_.MergeFrom(from.child_ids_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + tag_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.tag_name_); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_request()->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest::MergeFrom(from._internal_request()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_response()->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse::MergeFrom(from._internal_response()); + } + if (cached_has_bits & 0x00000010u) { + id_ = from.id_; + } + if (cached_has_bits & 0x00000020u) { + parent_id_ = from.parent_id_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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 ((_has_bits_[0] & 0x00000010) != 0x00000010) return false; + if (_internal_has_request()) { + if (!request_->IsInitialized()) return false; + } + if (_internal_has_response()) { + if (!response_->IsInitialized()) return false; + } + return true; +} + +void ClientSafeBrowsingReportRequest_Resource::InternalSwap(ClientSafeBrowsingReportRequest_Resource* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + child_ids_.InternalSwap(&other->child_ids_); + url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + tag_name_.Swap(&other->tag_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(request_, other->request_); + swap(response_, other->response_); + swap(id_, other->id_); + swap(parent_id_, other->parent_id_); +} + +std::string ClientSafeBrowsingReportRequest_Resource::GetTypeName() const { + return "safe_browsing.ClientSafeBrowsingReportRequest.Resource"; +} + + +// =================================================================== + +void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::InitAsDefaultInstance() { +} +class ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_Internal { + public: + using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties) +} +ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + client_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_client_version()) { + client_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.client_version_); + } + ::memcpy(&google_play_services_version_, &from.google_play_services_version_, + static_cast<size_t>(reinterpret_cast<char*>(&url_api_type_) - + reinterpret_cast<char*>(&google_play_services_version_)) + sizeof(url_api_type_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties) +} + +void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_csd_2eproto.base); + client_version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&google_play_services_version_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&url_api_type_) - + reinterpret_cast<char*>(&google_play_services_version_)) + sizeof(url_api_type_)); +} + +ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::~ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties) + SharedDtor(); +} + +void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::SharedDtor() { + client_version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + client_version_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x0000000eu) { + ::memset(&google_play_services_version_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&url_api_type_) - + reinterpret_cast<char*>(&google_play_services_version_)) + sizeof(url_api_type_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string client_version = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_client_version(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_google_play_services_version(&has_bits); + google_play_services_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool is_instant_apps = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _Internal::set_has_is_instant_apps(&has_bits); + is_instant_apps_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + 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 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_url_api_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties*>( + &from)); +} + +void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::MergeFrom(const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + client_version_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.client_version_); + } + if (cached_has_bits & 0x00000002u) { + google_play_services_version_ = from.google_play_services_version_; + } + if (cached_has_bits & 0x00000004u) { + is_instant_apps_ = from.is_instant_apps_; + } + if (cached_has_bits & 0x00000008u) { + url_api_type_ = from.url_api_type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + client_version_.Swap(&other->client_version_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(google_play_services_version_, other->google_play_services_version_); + swap(is_instant_apps_, other->is_instant_apps_); + swap(url_api_type_, other->url_api_type_); +} + +std::string ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::GetTypeName() const { + return "safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties"; +} + + +// =================================================================== + +void ClientSafeBrowsingReportRequest::InitAsDefaultInstance() { + ::safe_browsing::_ClientSafeBrowsingReportRequest_default_instance_._instance.get_mutable()->client_properties_ = const_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties*>( + ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::internal_default_instance()); +} +class ClientSafeBrowsingReportRequest::_Internal { + public: + using HasBits = decltype(std::declval<ClientSafeBrowsingReportRequest>()._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->client_properties_; +} +ClientSafeBrowsingReportRequest::ClientSafeBrowsingReportRequest() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest) +} +ClientSafeBrowsingReportRequest::ClientSafeBrowsingReportRequest(const ClientSafeBrowsingReportRequest& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + resources_(from.resources_), + client_asn_(from.client_asn_), + dom_(from.dom_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_url()) { + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + page_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_page_url()) { + page_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.page_url_); + } + referrer_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_referrer_url()) { + referrer_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_url_); + } + client_country_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_client_country()) { + client_country_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.client_country_); + } + token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_token()) { + token_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.token_); + } + if (from._internal_has_client_properties()) { + client_properties_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(*from.client_properties_); + } else { + client_properties_ = nullptr; + } + ::memcpy(&type_, &from.type_, + static_cast<size_t>(reinterpret_cast<char*>(&download_verdict_) - + reinterpret_cast<char*>(&type_)) + sizeof(download_verdict_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest) +} + +void ClientSafeBrowsingReportRequest::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ClientSafeBrowsingReportRequest_csd_2eproto.base); + url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + page_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + referrer_url_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + client_country_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&client_properties_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&download_verdict_) - + reinterpret_cast<char*>(&client_properties_)) + sizeof(download_verdict_)); +} + +ClientSafeBrowsingReportRequest::~ClientSafeBrowsingReportRequest() { + // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest) + SharedDtor(); +} + +void ClientSafeBrowsingReportRequest::SharedDtor() { + url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + page_url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + referrer_url_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + client_country_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + token_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete client_properties_; +} + +void ClientSafeBrowsingReportRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ClientSafeBrowsingReportRequest& ClientSafeBrowsingReportRequest::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ClientSafeBrowsingReportRequest_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ClientSafeBrowsingReportRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ClientSafeBrowsingReportRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + resources_.Clear(); + client_asn_.Clear(); + dom_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + page_url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + referrer_url_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000008u) { + client_country_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000010u) { + token_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(client_properties_ != nullptr); + client_properties_->Clear(); + } + } + if (cached_has_bits & 0x000000c0u) { + ::memset(&type_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&complete_) - + reinterpret_cast<char*>(&type_)) + sizeof(complete_)); + } + if (cached_has_bits & 0x00000f00u) { + ::memset(&did_proceed_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&download_verdict_) - + reinterpret_cast<char*>(&did_proceed_)) + sizeof(download_verdict_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ClientSafeBrowsingReportRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string url = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string page_url = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_page_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string referrer_url = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_referrer_url(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_complete(&has_bits); + complete_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string client_asn = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_client_asn(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + auto str = _internal_mutable_client_country(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool did_proceed = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + _Internal::set_has_did_proceed(&has_bits); + did_proceed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional bool repeat_visit = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) { + _Internal::set_has_repeat_visit(&has_bits); + repeat_visit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional .safe_browsing.ClientSafeBrowsingReportRequest.ReportType type = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) { + auto str = _internal_mutable_token(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) { + _Internal::set_has_show_download_in_folder(&has_bits); + show_download_in_folder_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ClientSafeBrowsingReportRequest::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ClientSafeBrowsingReportRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 int i = 0, + n = static_cast<unsigned int>(this->_internal_resources_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, this->_internal_resources(i), target, stream); + } + + // optional bool complete = 5; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_did_proceed(), target); + } + + // optional bool repeat_visit = 9; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::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 int i = 0, + n = static_cast<unsigned int>(this->_internal_dom_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(16, this->_internal_dom(i), target, stream); + } + + // optional .safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties client_properties = 17; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 17, _Internal::client_properties(this), target, stream); + } + + // optional bool show_download_in_folder = 18; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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->resources_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated string client_asn = 6; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(client_asn_.size()); + for (int i = 0, n = client_asn_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + client_asn_.Get(i)); + } + + // repeated .safe_browsing.HTMLElement dom = 16; + total_size += 2UL * this->_internal_dom_size(); + for (const auto& msg : this->dom_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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( + *client_properties_); + } + + // optional .safe_browsing.ClientSafeBrowsingReportRequest.ReportType type = 10; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::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 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_download_verdict()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ClientSafeBrowsingReportRequest::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ClientSafeBrowsingReportRequest*>( + &from)); +} + +void ClientSafeBrowsingReportRequest::MergeFrom(const ClientSafeBrowsingReportRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ClientSafeBrowsingReportRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + resources_.MergeFrom(from.resources_); + client_asn_.MergeFrom(from.client_asn_); + dom_.MergeFrom(from.dom_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.url_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + page_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.page_url_); + } + if (cached_has_bits & 0x00000004u) { + _has_bits_[0] |= 0x00000004u; + referrer_url_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.referrer_url_); + } + if (cached_has_bits & 0x00000008u) { + _has_bits_[0] |= 0x00000008u; + client_country_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.client_country_); + } + if (cached_has_bits & 0x00000010u) { + _has_bits_[0] |= 0x00000010u; + token_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.token_); + } + if (cached_has_bits & 0x00000020u) { + _internal_mutable_client_properties()->::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::MergeFrom(from._internal_client_properties()); + } + if (cached_has_bits & 0x00000040u) { + type_ = from.type_; + } + if (cached_has_bits & 0x00000080u) { + complete_ = from.complete_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000f00u) { + if (cached_has_bits & 0x00000100u) { + did_proceed_ = from.did_proceed_; + } + if (cached_has_bits & 0x00000200u) { + repeat_visit_ = from.repeat_visit_; + } + if (cached_has_bits & 0x00000400u) { + show_download_in_folder_ = from.show_download_in_folder_; + } + if (cached_has_bits & 0x00000800u) { + download_verdict_ = from.download_verdict_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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(resources_)) return false; + return true; +} + +void ClientSafeBrowsingReportRequest::InternalSwap(ClientSafeBrowsingReportRequest* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + resources_.InternalSwap(&other->resources_); + client_asn_.InternalSwap(&other->client_asn_); + dom_.InternalSwap(&other->dom_); + url_.Swap(&other->url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + page_url_.Swap(&other->page_url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + referrer_url_.Swap(&other->referrer_url_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + client_country_.Swap(&other->client_country_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + token_.Swap(&other->token_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(client_properties_, other->client_properties_); + swap(type_, other->type_); + swap(complete_, other->complete_); + swap(did_proceed_, other->did_proceed_); + swap(repeat_visit_, other->repeat_visit_); + swap(show_download_in_folder_, other->show_download_in_folder_); + swap(download_verdict_, other->download_verdict_); +} + +std::string ClientSafeBrowsingReportRequest::GetTypeName() const { + return "safe_browsing.ClientSafeBrowsingReportRequest"; +} + + +// =================================================================== + +void HTMLElement_Attribute::InitAsDefaultInstance() { +} +class HTMLElement_Attribute::_Internal { + public: + using HasBits = decltype(std::declval<HTMLElement_Attribute>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.HTMLElement.Attribute) +} +HTMLElement_Attribute::HTMLElement_Attribute(const HTMLElement_Attribute& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_name()) { + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_value()) { + value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_); + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.HTMLElement.Attribute) +} + +void HTMLElement_Attribute::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HTMLElement_Attribute_csd_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +HTMLElement_Attribute::~HTMLElement_Attribute() { + // @@protoc_insertion_point(destructor:safe_browsing.HTMLElement.Attribute) + SharedDtor(); +} + +void HTMLElement_Attribute::SharedDtor() { + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void HTMLElement_Attribute::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HTMLElement_Attribute& HTMLElement_Attribute::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HTMLElement_Attribute_csd_2eproto.base); + return *internal_default_instance(); +} + + +void HTMLElement_Attribute::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.HTMLElement.Attribute) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + value_.ClearNonDefaultToEmptyNoArena(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* HTMLElement_Attribute::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_value(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* HTMLElement_Attribute::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.HTMLElement.Attribute) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HTMLElement_Attribute::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const HTMLElement_Attribute*>( + &from)); +} + +void HTMLElement_Attribute::MergeFrom(const HTMLElement_Attribute& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.HTMLElement.Attribute) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.value_); + } + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +std::string HTMLElement_Attribute::GetTypeName() const { + return "safe_browsing.HTMLElement.Attribute"; +} + + +// =================================================================== + +void HTMLElement::InitAsDefaultInstance() { +} +class HTMLElement::_Internal { + public: + using HasBits = decltype(std::declval<HTMLElement>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.HTMLElement) +} +HTMLElement::HTMLElement(const HTMLElement& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_), + child_ids_(from.child_ids_), + attribute_(from.attribute_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_tag()) { + tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.tag_); + } + ::memcpy(&id_, &from.id_, + static_cast<size_t>(reinterpret_cast<char*>(&resource_id_) - + reinterpret_cast<char*>(&id_)) + sizeof(resource_id_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.HTMLElement) +} + +void HTMLElement::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HTMLElement_csd_2eproto.base); + tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&id_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&resource_id_) - + reinterpret_cast<char*>(&id_)) + sizeof(resource_id_)); +} + +HTMLElement::~HTMLElement() { + // @@protoc_insertion_point(destructor:safe_browsing.HTMLElement) + SharedDtor(); +} + +void HTMLElement::SharedDtor() { + tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void HTMLElement::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HTMLElement& HTMLElement::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HTMLElement_csd_2eproto.base); + return *internal_default_instance(); +} + + +void HTMLElement::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.HTMLElement) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + child_ids_.Clear(); + attribute_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + tag_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&id_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&resource_id_) - + reinterpret_cast<char*>(&id_)) + sizeof(resource_id_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* HTMLElement::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional int32 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_id(&has_bits); + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string tag = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_tag(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int32 child_ids = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_child_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr)); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _Internal::set_has_resource_id(&has_bits); + resource_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .safe_browsing.HTMLElement.Attribute attribute = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(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: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* HTMLElement::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.HTMLElement) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 id = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_child_ids(i), target); + } + + // optional int32 resource_id = 5; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_resource_id(), target); + } + + // repeated .safe_browsing.HTMLElement.Attribute attribute = 6; + for (unsigned int i = 0, + n = static_cast<unsigned int>(this->_internal_attribute_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(6, this->_internal_attribute(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 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 = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->child_ids_); + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::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->attribute_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _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 += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_id()); + } + + // optional int32 resource_id = 5; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_resource_id()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HTMLElement::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const HTMLElement*>( + &from)); +} + +void HTMLElement::MergeFrom(const HTMLElement& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.HTMLElement) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + child_ids_.MergeFrom(from.child_ids_); + attribute_.MergeFrom(from.attribute_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.tag_); + } + if (cached_has_bits & 0x00000002u) { + id_ = from.id_; + } + if (cached_has_bits & 0x00000004u) { + resource_id_ = from.resource_id_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + child_ids_.InternalSwap(&other->child_ids_); + attribute_.InternalSwap(&other->attribute_); + tag_.Swap(&other->tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(id_, other->id_); + swap(resource_id_, other->resource_id_); +} + +std::string HTMLElement::GetTypeName() const { + return "safe_browsing.HTMLElement"; +} + + +// =================================================================== + +void ImageData_Dimensions::InitAsDefaultInstance() { +} +class ImageData_Dimensions::_Internal { + public: + using HasBits = decltype(std::declval<ImageData_Dimensions>()._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::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ImageData.Dimensions) +} +ImageData_Dimensions::ImageData_Dimensions(const ImageData_Dimensions& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&width_, &from.width_, + static_cast<size_t>(reinterpret_cast<char*>(&height_) - + reinterpret_cast<char*>(&width_)) + sizeof(height_)); + // @@protoc_insertion_point(copy_constructor:safe_browsing.ImageData.Dimensions) +} + +void ImageData_Dimensions::SharedCtor() { + ::memset(&width_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&height_) - + reinterpret_cast<char*>(&width_)) + sizeof(height_)); +} + +ImageData_Dimensions::~ImageData_Dimensions() { + // @@protoc_insertion_point(destructor:safe_browsing.ImageData.Dimensions) + SharedDtor(); +} + +void ImageData_Dimensions::SharedDtor() { +} + +void ImageData_Dimensions::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ImageData_Dimensions& ImageData_Dimensions::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ImageData_Dimensions_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ImageData_Dimensions::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ImageData.Dimensions) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&width_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&height_) - + reinterpret_cast<char*>(&width_)) + sizeof(height_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ImageData_Dimensions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional int32 width = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _Internal::set_has_width(&has_bits); + width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional int32 height = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _Internal::set_has_height(&has_bits); + height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ImageData_Dimensions::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ImageData.Dimensions) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 width = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_width(), target); + } + + // optional int32 height = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_height(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional int32 width = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_width()); + } + + // optional int32 height = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_height()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ImageData_Dimensions::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ImageData_Dimensions*>( + &from)); +} + +void ImageData_Dimensions::MergeFrom(const ImageData_Dimensions& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ImageData.Dimensions) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + width_ = from.width_; + } + if (cached_has_bits & 0x00000002u) { + height_ = from.height_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +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_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(width_, other->width_); + swap(height_, other->height_); +} + +std::string ImageData_Dimensions::GetTypeName() const { + return "safe_browsing.ImageData.Dimensions"; +} + + +// =================================================================== + +void ImageData::InitAsDefaultInstance() { + ::safe_browsing::_ImageData_default_instance_._instance.get_mutable()->dimensions_ = const_cast< ::safe_browsing::ImageData_Dimensions*>( + ::safe_browsing::ImageData_Dimensions::internal_default_instance()); + ::safe_browsing::_ImageData_default_instance_._instance.get_mutable()->original_dimensions_ = const_cast< ::safe_browsing::ImageData_Dimensions*>( + ::safe_browsing::ImageData_Dimensions::internal_default_instance()); +} +class ImageData::_Internal { + public: + using HasBits = decltype(std::declval<ImageData>()._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->dimensions_; +} +const ::safe_browsing::ImageData_Dimensions& +ImageData::_Internal::original_dimensions(const ImageData* msg) { + return *msg->original_dimensions_; +} +ImageData::ImageData() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.ImageData) +} +ImageData::ImageData(const ImageData& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_data()) { + data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_); + } + mime_type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_mime_type()) { + mime_type_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.mime_type_); + } + if (from._internal_has_dimensions()) { + dimensions_ = new ::safe_browsing::ImageData_Dimensions(*from.dimensions_); + } else { + dimensions_ = nullptr; + } + if (from._internal_has_original_dimensions()) { + original_dimensions_ = new ::safe_browsing::ImageData_Dimensions(*from.original_dimensions_); + } else { + original_dimensions_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.ImageData) +} + +void ImageData::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ImageData_csd_2eproto.base); + data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + mime_type_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&dimensions_, 0, static_cast<size_t>( + reinterpret_cast<char*>(&original_dimensions_) - + reinterpret_cast<char*>(&dimensions_)) + sizeof(original_dimensions_)); +} + +ImageData::~ImageData() { + // @@protoc_insertion_point(destructor:safe_browsing.ImageData) + SharedDtor(); +} + +void ImageData::SharedDtor() { + data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + mime_type_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete dimensions_; + if (this != internal_default_instance()) delete original_dimensions_; +} + +void ImageData::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ImageData& ImageData::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ImageData_csd_2eproto.base); + return *internal_default_instance(); +} + + +void ImageData::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.ImageData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + data_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + mime_type_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(dimensions_ != nullptr); + dimensions_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(original_dimensions_ != nullptr); + original_dimensions_->Clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ImageData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional bytes data = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_data(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // optional string mime_type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_mime_type(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_original_dimensions(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ImageData::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.ImageData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::dimensions(this), target, stream); + } + + // optional .safe_browsing.ImageData.Dimensions original_dimensions = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::original_dimensions(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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( + *dimensions_); + } + + // optional .safe_browsing.ImageData.Dimensions original_dimensions = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *original_dimensions_); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ImageData::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ImageData*>( + &from)); +} + +void ImageData::MergeFrom(const ImageData& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.ImageData) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.data_); + } + if (cached_has_bits & 0x00000002u) { + _has_bits_[0] |= 0x00000002u; + mime_type_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.mime_type_); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_dimensions()->::safe_browsing::ImageData_Dimensions::MergeFrom(from._internal_dimensions()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_original_dimensions()->::safe_browsing::ImageData_Dimensions::MergeFrom(from._internal_original_dimensions()); + } + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + mime_type_.Swap(&other->mime_type_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(dimensions_, other->dimensions_); + swap(original_dimensions_, other->original_dimensions_); +} + +std::string ImageData::GetTypeName() const { + return "safe_browsing.ImageData"; +} + + +// =================================================================== + +void NotificationImageReportRequest::InitAsDefaultInstance() { + ::safe_browsing::_NotificationImageReportRequest_default_instance_._instance.get_mutable()->image_ = const_cast< ::safe_browsing::ImageData*>( + ::safe_browsing::ImageData::internal_default_instance()); +} +class NotificationImageReportRequest::_Internal { + public: + using HasBits = decltype(std::declval<NotificationImageReportRequest>()._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->image_; +} +NotificationImageReportRequest::NotificationImageReportRequest() + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:safe_browsing.NotificationImageReportRequest) +} +NotificationImageReportRequest::NotificationImageReportRequest(const NotificationImageReportRequest& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _internal_metadata_(nullptr), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + notification_origin_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (from._internal_has_notification_origin()) { + notification_origin_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.notification_origin_); + } + if (from._internal_has_image()) { + image_ = new ::safe_browsing::ImageData(*from.image_); + } else { + image_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:safe_browsing.NotificationImageReportRequest) +} + +void NotificationImageReportRequest::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_NotificationImageReportRequest_csd_2eproto.base); + notification_origin_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + image_ = nullptr; +} + +NotificationImageReportRequest::~NotificationImageReportRequest() { + // @@protoc_insertion_point(destructor:safe_browsing.NotificationImageReportRequest) + SharedDtor(); +} + +void NotificationImageReportRequest::SharedDtor() { + notification_origin_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete image_; +} + +void NotificationImageReportRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const NotificationImageReportRequest& NotificationImageReportRequest::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_NotificationImageReportRequest_csd_2eproto.base); + return *internal_default_instance(); +} + + +void NotificationImageReportRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:safe_browsing.NotificationImageReportRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + notification_origin_.ClearNonDefaultToEmptyNoArena(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(image_ != nullptr); + image_->Clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* NotificationImageReportRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // optional string notification_origin = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_notification_origin(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::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<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_image(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* NotificationImageReportRequest::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:safe_browsing.NotificationImageReportRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _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 = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::image(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields().data(), + static_cast<int>(_internal_metadata_.unknown_fields().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; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _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( + *image_); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields().size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void NotificationImageReportRequest::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const NotificationImageReportRequest*>( + &from)); +} + +void NotificationImageReportRequest::MergeFrom(const NotificationImageReportRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:safe_browsing.NotificationImageReportRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _has_bits_[0] |= 0x00000001u; + notification_origin_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.notification_origin_); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_image()->::safe_browsing::ImageData::MergeFrom(from._internal_image()); + } + } +} + +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; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + notification_origin_.Swap(&other->notification_origin_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(image_, other->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::CreateInternal< ::safe_browsing::ChromeUserPopulation >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientPhishingRequest_Feature* Arena::CreateMaybeMessage< ::safe_browsing::ClientPhishingRequest_Feature >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientPhishingRequest_Feature >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientPhishingRequest* Arena::CreateMaybeMessage< ::safe_browsing::ClientPhishingRequest >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientPhishingRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientPhishingResponse* Arena::CreateMaybeMessage< ::safe_browsing::ClientPhishingResponse >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientPhishingResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientMalwareRequest_UrlInfo* Arena::CreateMaybeMessage< ::safe_browsing::ClientMalwareRequest_UrlInfo >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientMalwareRequest_UrlInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientMalwareRequest* Arena::CreateMaybeMessage< ::safe_browsing::ClientMalwareRequest >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientMalwareRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::LoginReputationClientRequest_Frame_Form* Arena::CreateMaybeMessage< ::safe_browsing::LoginReputationClientRequest_Frame_Form >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::LoginReputationClientRequest_Frame_Form >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::LoginReputationClientRequest_Frame* Arena::CreateMaybeMessage< ::safe_browsing::LoginReputationClientRequest_Frame >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::LoginReputationClientRequest_Frame >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* Arena::CreateMaybeMessage< ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::LoginReputationClientRequest* Arena::CreateMaybeMessage< ::safe_browsing::LoginReputationClientRequest >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::LoginReputationClientRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::LoginReputationClientResponse* Arena::CreateMaybeMessage< ::safe_browsing::LoginReputationClientResponse >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::LoginReputationClientResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientMalwareResponse* Arena::CreateMaybeMessage< ::safe_browsing::ClientMalwareResponse >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientMalwareResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_Digests* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_Digests >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadRequest_Digests >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_Resource* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_Resource >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadRequest_Resource >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_CertificateChain* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_CertificateChain >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadRequest_CertificateChain >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_ExtendedAttr* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_ExtendedAttr >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadRequest_ExtendedAttr >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_SignatureInfo* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_SignatureInfo >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadRequest_SignatureInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_PEImageHeaders* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_PEImageHeaders >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadRequest_PEImageHeaders >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_MachOHeaders* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_MachOHeaders >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadRequest_MachOHeaders >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_ImageHeaders* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_ImageHeaders >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadRequest_ImageHeaders >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest_ArchivedBinary* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest_ArchivedBinary >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadRequest_ArchivedBinary >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadRequest* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadRequest >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ReferrerChainEntry_ServerRedirect* Arena::CreateMaybeMessage< ::safe_browsing::ReferrerChainEntry_ServerRedirect >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ReferrerChainEntry_ServerRedirect >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ReferrerChainEntry* Arena::CreateMaybeMessage< ::safe_browsing::ReferrerChainEntry >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ReferrerChainEntry >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadResponse_MoreInfo* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadResponse_MoreInfo >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadResponse_MoreInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadResponse* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadResponse >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadReport_UserInformation* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadReport_UserInformation >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadReport_UserInformation >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientDownloadReport* Arena::CreateMaybeMessage< ::safe_browsing::ClientDownloadReport >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientDownloadReport >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientUploadResponse* Arena::CreateMaybeMessage< ::safe_browsing::ClientUploadResponse >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientUploadResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident >(Arena* arena) { + return Arena::CreateInternal< ::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::CreateInternal< ::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::CreateInternal< ::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::CreateInternal< ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_IncidentData* Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_IncidentData >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientIncidentReport_IncidentData >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_DownloadDetails* Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_DownloadDetails >(Arena* arena) { + return Arena::CreateInternal< ::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::CreateInternal< ::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::CreateInternal< ::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::CreateInternal< ::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::CreateInternal< ::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::CreateInternal< ::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::CreateInternal< ::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::CreateInternal< ::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::CreateInternal< ::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::CreateInternal< ::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::CreateInternal< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_EnvironmentData* Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_EnvironmentData >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientIncidentReport_EnvironmentData >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_ExtensionData* Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_ExtensionData >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientIncidentReport_ExtensionData >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentReport* Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentReport >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientIncidentReport >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentResponse_EnvironmentRequest* Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientIncidentResponse* Arena::CreateMaybeMessage< ::safe_browsing::ClientIncidentResponse >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientIncidentResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::DownloadMetadata* Arena::CreateMaybeMessage< ::safe_browsing::DownloadMetadata >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::DownloadMetadata >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ClientSafeBrowsingReportRequest* Arena::CreateMaybeMessage< ::safe_browsing::ClientSafeBrowsingReportRequest >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ClientSafeBrowsingReportRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::HTMLElement_Attribute* Arena::CreateMaybeMessage< ::safe_browsing::HTMLElement_Attribute >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::HTMLElement_Attribute >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::HTMLElement* Arena::CreateMaybeMessage< ::safe_browsing::HTMLElement >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::HTMLElement >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ImageData_Dimensions* Arena::CreateMaybeMessage< ::safe_browsing::ImageData_Dimensions >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ImageData_Dimensions >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::ImageData* Arena::CreateMaybeMessage< ::safe_browsing::ImageData >(Arena* arena) { + return Arena::CreateInternal< ::safe_browsing::ImageData >(arena); +} +template<> PROTOBUF_NOINLINE ::safe_browsing::NotificationImageReportRequest* Arena::CreateMaybeMessage< ::safe_browsing::NotificationImageReportRequest >(Arena* arena) { + return Arena::CreateInternal< ::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..1fabc4a78b --- /dev/null +++ b/toolkit/components/reputationservice/chromium/chrome/common/safe_browsing/csd.pb.h @@ -0,0 +1,30355 @@ +// 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 < 3011000 +#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 3011004 < 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_table_driven.h> +#include <google/protobuf/generated_message_util.h> +#include <google/protobuf/inlined_string_field.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 ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[69] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +namespace safe_browsing { +class ChromeUserPopulation; +class ChromeUserPopulationDefaultTypeInternal; +extern ChromeUserPopulationDefaultTypeInternal _ChromeUserPopulation_default_instance_; +class ClientDownloadReport; +class ClientDownloadReportDefaultTypeInternal; +extern ClientDownloadReportDefaultTypeInternal _ClientDownloadReport_default_instance_; +class ClientDownloadReport_UserInformation; +class ClientDownloadReport_UserInformationDefaultTypeInternal; +extern ClientDownloadReport_UserInformationDefaultTypeInternal _ClientDownloadReport_UserInformation_default_instance_; +class ClientDownloadRequest; +class ClientDownloadRequestDefaultTypeInternal; +extern ClientDownloadRequestDefaultTypeInternal _ClientDownloadRequest_default_instance_; +class ClientDownloadRequest_ArchivedBinary; +class ClientDownloadRequest_ArchivedBinaryDefaultTypeInternal; +extern ClientDownloadRequest_ArchivedBinaryDefaultTypeInternal _ClientDownloadRequest_ArchivedBinary_default_instance_; +class ClientDownloadRequest_CertificateChain; +class ClientDownloadRequest_CertificateChainDefaultTypeInternal; +extern ClientDownloadRequest_CertificateChainDefaultTypeInternal _ClientDownloadRequest_CertificateChain_default_instance_; +class ClientDownloadRequest_CertificateChain_Element; +class ClientDownloadRequest_CertificateChain_ElementDefaultTypeInternal; +extern ClientDownloadRequest_CertificateChain_ElementDefaultTypeInternal _ClientDownloadRequest_CertificateChain_Element_default_instance_; +class ClientDownloadRequest_Digests; +class ClientDownloadRequest_DigestsDefaultTypeInternal; +extern ClientDownloadRequest_DigestsDefaultTypeInternal _ClientDownloadRequest_Digests_default_instance_; +class ClientDownloadRequest_ExtendedAttr; +class ClientDownloadRequest_ExtendedAttrDefaultTypeInternal; +extern ClientDownloadRequest_ExtendedAttrDefaultTypeInternal _ClientDownloadRequest_ExtendedAttr_default_instance_; +class ClientDownloadRequest_ImageHeaders; +class ClientDownloadRequest_ImageHeadersDefaultTypeInternal; +extern ClientDownloadRequest_ImageHeadersDefaultTypeInternal _ClientDownloadRequest_ImageHeaders_default_instance_; +class ClientDownloadRequest_MachOHeaders; +class ClientDownloadRequest_MachOHeadersDefaultTypeInternal; +extern ClientDownloadRequest_MachOHeadersDefaultTypeInternal _ClientDownloadRequest_MachOHeaders_default_instance_; +class ClientDownloadRequest_MachOHeaders_LoadCommand; +class ClientDownloadRequest_MachOHeaders_LoadCommandDefaultTypeInternal; +extern ClientDownloadRequest_MachOHeaders_LoadCommandDefaultTypeInternal _ClientDownloadRequest_MachOHeaders_LoadCommand_default_instance_; +class ClientDownloadRequest_PEImageHeaders; +class ClientDownloadRequest_PEImageHeadersDefaultTypeInternal; +extern ClientDownloadRequest_PEImageHeadersDefaultTypeInternal _ClientDownloadRequest_PEImageHeaders_default_instance_; +class ClientDownloadRequest_PEImageHeaders_DebugData; +class ClientDownloadRequest_PEImageHeaders_DebugDataDefaultTypeInternal; +extern ClientDownloadRequest_PEImageHeaders_DebugDataDefaultTypeInternal _ClientDownloadRequest_PEImageHeaders_DebugData_default_instance_; +class ClientDownloadRequest_Resource; +class ClientDownloadRequest_ResourceDefaultTypeInternal; +extern ClientDownloadRequest_ResourceDefaultTypeInternal _ClientDownloadRequest_Resource_default_instance_; +class ClientDownloadRequest_SignatureInfo; +class ClientDownloadRequest_SignatureInfoDefaultTypeInternal; +extern ClientDownloadRequest_SignatureInfoDefaultTypeInternal _ClientDownloadRequest_SignatureInfo_default_instance_; +class ClientDownloadResponse; +class ClientDownloadResponseDefaultTypeInternal; +extern ClientDownloadResponseDefaultTypeInternal _ClientDownloadResponse_default_instance_; +class ClientDownloadResponse_MoreInfo; +class ClientDownloadResponse_MoreInfoDefaultTypeInternal; +extern ClientDownloadResponse_MoreInfoDefaultTypeInternal _ClientDownloadResponse_MoreInfo_default_instance_; +class ClientIncidentReport; +class ClientIncidentReportDefaultTypeInternal; +extern ClientIncidentReportDefaultTypeInternal _ClientIncidentReport_default_instance_; +class ClientIncidentReport_DownloadDetails; +class ClientIncidentReport_DownloadDetailsDefaultTypeInternal; +extern ClientIncidentReport_DownloadDetailsDefaultTypeInternal _ClientIncidentReport_DownloadDetails_default_instance_; +class ClientIncidentReport_EnvironmentData; +class ClientIncidentReport_EnvironmentDataDefaultTypeInternal; +extern ClientIncidentReport_EnvironmentDataDefaultTypeInternal _ClientIncidentReport_EnvironmentData_default_instance_; +class ClientIncidentReport_EnvironmentData_Machine; +class ClientIncidentReport_EnvironmentData_MachineDefaultTypeInternal; +extern ClientIncidentReport_EnvironmentData_MachineDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Machine_default_instance_; +class ClientIncidentReport_EnvironmentData_OS; +class ClientIncidentReport_EnvironmentData_OSDefaultTypeInternal; +extern ClientIncidentReport_EnvironmentData_OSDefaultTypeInternal _ClientIncidentReport_EnvironmentData_OS_default_instance_; +class ClientIncidentReport_EnvironmentData_OS_RegistryKey; +class ClientIncidentReport_EnvironmentData_OS_RegistryKeyDefaultTypeInternal; +extern ClientIncidentReport_EnvironmentData_OS_RegistryKeyDefaultTypeInternal _ClientIncidentReport_EnvironmentData_OS_RegistryKey_default_instance_; +class ClientIncidentReport_EnvironmentData_OS_RegistryValue; +class ClientIncidentReport_EnvironmentData_OS_RegistryValueDefaultTypeInternal; +extern ClientIncidentReport_EnvironmentData_OS_RegistryValueDefaultTypeInternal _ClientIncidentReport_EnvironmentData_OS_RegistryValue_default_instance_; +class ClientIncidentReport_EnvironmentData_Process; +class ClientIncidentReport_EnvironmentData_ProcessDefaultTypeInternal; +extern ClientIncidentReport_EnvironmentData_ProcessDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_default_instance_; +class ClientIncidentReport_EnvironmentData_Process_Dll; +class ClientIncidentReport_EnvironmentData_Process_DllDefaultTypeInternal; +extern ClientIncidentReport_EnvironmentData_Process_DllDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_Dll_default_instance_; +class ClientIncidentReport_EnvironmentData_Process_ModuleState; +class ClientIncidentReport_EnvironmentData_Process_ModuleStateDefaultTypeInternal; +extern ClientIncidentReport_EnvironmentData_Process_ModuleStateDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_ModuleState_default_instance_; +class ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification; +class ClientIncidentReport_EnvironmentData_Process_ModuleState_ModificationDefaultTypeInternal; +extern ClientIncidentReport_EnvironmentData_Process_ModuleState_ModificationDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification_default_instance_; +class ClientIncidentReport_EnvironmentData_Process_NetworkProvider; +class ClientIncidentReport_EnvironmentData_Process_NetworkProviderDefaultTypeInternal; +extern ClientIncidentReport_EnvironmentData_Process_NetworkProviderDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_NetworkProvider_default_instance_; +class ClientIncidentReport_EnvironmentData_Process_Patch; +class ClientIncidentReport_EnvironmentData_Process_PatchDefaultTypeInternal; +extern ClientIncidentReport_EnvironmentData_Process_PatchDefaultTypeInternal _ClientIncidentReport_EnvironmentData_Process_Patch_default_instance_; +class ClientIncidentReport_ExtensionData; +class ClientIncidentReport_ExtensionDataDefaultTypeInternal; +extern ClientIncidentReport_ExtensionDataDefaultTypeInternal _ClientIncidentReport_ExtensionData_default_instance_; +class ClientIncidentReport_ExtensionData_ExtensionInfo; +class ClientIncidentReport_ExtensionData_ExtensionInfoDefaultTypeInternal; +extern ClientIncidentReport_ExtensionData_ExtensionInfoDefaultTypeInternal _ClientIncidentReport_ExtensionData_ExtensionInfo_default_instance_; +class ClientIncidentReport_IncidentData; +class ClientIncidentReport_IncidentDataDefaultTypeInternal; +extern ClientIncidentReport_IncidentDataDefaultTypeInternal _ClientIncidentReport_IncidentData_default_instance_; +class ClientIncidentReport_IncidentData_BinaryIntegrityIncident; +class ClientIncidentReport_IncidentData_BinaryIntegrityIncidentDefaultTypeInternal; +extern ClientIncidentReport_IncidentData_BinaryIntegrityIncidentDefaultTypeInternal _ClientIncidentReport_IncidentData_BinaryIntegrityIncident_default_instance_; +class ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile; +class ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFileDefaultTypeInternal; +extern ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFileDefaultTypeInternal _ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile_default_instance_; +class ClientIncidentReport_IncidentData_ResourceRequestIncident; +class ClientIncidentReport_IncidentData_ResourceRequestIncidentDefaultTypeInternal; +extern ClientIncidentReport_IncidentData_ResourceRequestIncidentDefaultTypeInternal _ClientIncidentReport_IncidentData_ResourceRequestIncident_default_instance_; +class ClientIncidentReport_IncidentData_TrackedPreferenceIncident; +class ClientIncidentReport_IncidentData_TrackedPreferenceIncidentDefaultTypeInternal; +extern ClientIncidentReport_IncidentData_TrackedPreferenceIncidentDefaultTypeInternal _ClientIncidentReport_IncidentData_TrackedPreferenceIncident_default_instance_; +class ClientIncidentReport_NonBinaryDownloadDetails; +class ClientIncidentReport_NonBinaryDownloadDetailsDefaultTypeInternal; +extern ClientIncidentReport_NonBinaryDownloadDetailsDefaultTypeInternal _ClientIncidentReport_NonBinaryDownloadDetails_default_instance_; +class ClientIncidentResponse; +class ClientIncidentResponseDefaultTypeInternal; +extern ClientIncidentResponseDefaultTypeInternal _ClientIncidentResponse_default_instance_; +class ClientIncidentResponse_EnvironmentRequest; +class ClientIncidentResponse_EnvironmentRequestDefaultTypeInternal; +extern ClientIncidentResponse_EnvironmentRequestDefaultTypeInternal _ClientIncidentResponse_EnvironmentRequest_default_instance_; +class ClientMalwareRequest; +class ClientMalwareRequestDefaultTypeInternal; +extern ClientMalwareRequestDefaultTypeInternal _ClientMalwareRequest_default_instance_; +class ClientMalwareRequest_UrlInfo; +class ClientMalwareRequest_UrlInfoDefaultTypeInternal; +extern ClientMalwareRequest_UrlInfoDefaultTypeInternal _ClientMalwareRequest_UrlInfo_default_instance_; +class ClientMalwareResponse; +class ClientMalwareResponseDefaultTypeInternal; +extern ClientMalwareResponseDefaultTypeInternal _ClientMalwareResponse_default_instance_; +class ClientPhishingRequest; +class ClientPhishingRequestDefaultTypeInternal; +extern ClientPhishingRequestDefaultTypeInternal _ClientPhishingRequest_default_instance_; +class ClientPhishingRequest_Feature; +class ClientPhishingRequest_FeatureDefaultTypeInternal; +extern ClientPhishingRequest_FeatureDefaultTypeInternal _ClientPhishingRequest_Feature_default_instance_; +class ClientPhishingResponse; +class ClientPhishingResponseDefaultTypeInternal; +extern ClientPhishingResponseDefaultTypeInternal _ClientPhishingResponse_default_instance_; +class ClientSafeBrowsingReportRequest; +class ClientSafeBrowsingReportRequestDefaultTypeInternal; +extern ClientSafeBrowsingReportRequestDefaultTypeInternal _ClientSafeBrowsingReportRequest_default_instance_; +class ClientSafeBrowsingReportRequest_HTTPHeader; +class ClientSafeBrowsingReportRequest_HTTPHeaderDefaultTypeInternal; +extern ClientSafeBrowsingReportRequest_HTTPHeaderDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPHeader_default_instance_; +class ClientSafeBrowsingReportRequest_HTTPRequest; +class ClientSafeBrowsingReportRequest_HTTPRequestDefaultTypeInternal; +extern ClientSafeBrowsingReportRequest_HTTPRequestDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPRequest_default_instance_; +class ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine; +class ClientSafeBrowsingReportRequest_HTTPRequest_FirstLineDefaultTypeInternal; +extern ClientSafeBrowsingReportRequest_HTTPRequest_FirstLineDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine_default_instance_; +class ClientSafeBrowsingReportRequest_HTTPResponse; +class ClientSafeBrowsingReportRequest_HTTPResponseDefaultTypeInternal; +extern ClientSafeBrowsingReportRequest_HTTPResponseDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPResponse_default_instance_; +class ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine; +class ClientSafeBrowsingReportRequest_HTTPResponse_FirstLineDefaultTypeInternal; +extern ClientSafeBrowsingReportRequest_HTTPResponse_FirstLineDefaultTypeInternal _ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine_default_instance_; +class ClientSafeBrowsingReportRequest_Resource; +class ClientSafeBrowsingReportRequest_ResourceDefaultTypeInternal; +extern ClientSafeBrowsingReportRequest_ResourceDefaultTypeInternal _ClientSafeBrowsingReportRequest_Resource_default_instance_; +class ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties; +class ClientSafeBrowsingReportRequest_SafeBrowsingClientPropertiesDefaultTypeInternal; +extern ClientSafeBrowsingReportRequest_SafeBrowsingClientPropertiesDefaultTypeInternal _ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties_default_instance_; +class ClientUploadResponse; +class ClientUploadResponseDefaultTypeInternal; +extern ClientUploadResponseDefaultTypeInternal _ClientUploadResponse_default_instance_; +class DownloadMetadata; +class DownloadMetadataDefaultTypeInternal; +extern DownloadMetadataDefaultTypeInternal _DownloadMetadata_default_instance_; +class HTMLElement; +class HTMLElementDefaultTypeInternal; +extern HTMLElementDefaultTypeInternal _HTMLElement_default_instance_; +class HTMLElement_Attribute; +class HTMLElement_AttributeDefaultTypeInternal; +extern HTMLElement_AttributeDefaultTypeInternal _HTMLElement_Attribute_default_instance_; +class ImageData; +class ImageDataDefaultTypeInternal; +extern ImageDataDefaultTypeInternal _ImageData_default_instance_; +class ImageData_Dimensions; +class ImageData_DimensionsDefaultTypeInternal; +extern ImageData_DimensionsDefaultTypeInternal _ImageData_Dimensions_default_instance_; +class LoginReputationClientRequest; +class LoginReputationClientRequestDefaultTypeInternal; +extern LoginReputationClientRequestDefaultTypeInternal _LoginReputationClientRequest_default_instance_; +class LoginReputationClientRequest_Frame; +class LoginReputationClientRequest_FrameDefaultTypeInternal; +extern LoginReputationClientRequest_FrameDefaultTypeInternal _LoginReputationClientRequest_Frame_default_instance_; +class LoginReputationClientRequest_Frame_Form; +class LoginReputationClientRequest_Frame_FormDefaultTypeInternal; +extern LoginReputationClientRequest_Frame_FormDefaultTypeInternal _LoginReputationClientRequest_Frame_Form_default_instance_; +class LoginReputationClientRequest_PasswordReuseEvent; +class LoginReputationClientRequest_PasswordReuseEventDefaultTypeInternal; +extern LoginReputationClientRequest_PasswordReuseEventDefaultTypeInternal _LoginReputationClientRequest_PasswordReuseEvent_default_instance_; +class LoginReputationClientResponse; +class LoginReputationClientResponseDefaultTypeInternal; +extern LoginReputationClientResponseDefaultTypeInternal _LoginReputationClientResponse_default_instance_; +class NotificationImageReportRequest; +class NotificationImageReportRequestDefaultTypeInternal; +extern NotificationImageReportRequestDefaultTypeInternal _NotificationImageReportRequest_default_instance_; +class ReferrerChainEntry; +class ReferrerChainEntryDefaultTypeInternal; +extern ReferrerChainEntryDefaultTypeInternal _ReferrerChainEntry_default_instance_; +class ReferrerChainEntry_ServerRedirect; +class 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& 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( + const std::string& name, ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType* value); +// =================================================================== + +class ChromeUserPopulation : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ChromeUserPopulation) */ { + public: + ChromeUserPopulation(); + virtual ~ChromeUserPopulation(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ChromeUserPopulation& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ChromeUserPopulation* New() const final { + return CreateMaybeMessage<ChromeUserPopulation>(nullptr); + } + + ChromeUserPopulation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ChromeUserPopulation* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ChromeUserPopulation"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientPhishingRequest_Feature : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientPhishingRequest.Feature) */ { + public: + ClientPhishingRequest_Feature(); + virtual ~ClientPhishingRequest_Feature(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientPhishingRequest_Feature& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientPhishingRequest_Feature* New() const final { + return CreateMaybeMessage<ClientPhishingRequest_Feature>(nullptr); + } + + ClientPhishingRequest_Feature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientPhishingRequest_Feature* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientPhishingRequest.Feature"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + double value_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientPhishingRequest : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientPhishingRequest) */ { + public: + ClientPhishingRequest(); + virtual ~ClientPhishingRequest(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientPhishingRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientPhishingRequest* New() const final { + return CreateMaybeMessage<ClientPhishingRequest>(nullptr); + } + + ClientPhishingRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientPhishingRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientPhishingRequest"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_shingle_hashes(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + _internal_shingle_hashes() const; + void _internal_add_shingle_hashes(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + _internal_mutable_shingle_hashes(); + public: + ::PROTOBUF_NAMESPACE_ID::uint32 shingle_hashes(int index) const; + void set_shingle_hashes(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value); + void add_shingle_hashes(::PROTOBUF_NAMESPACE_ID::uint32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& + shingle_hashes() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* + 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; + void set_url(const std::string& value); + void set_url(std::string&& value); + void set_url(const char* value); + void set_url(const char* value, size_t size); + std::string* mutable_url(); + std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + 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; + void set_obsolete_referrer_url(const std::string& value); + void set_obsolete_referrer_url(std::string&& value); + void set_obsolete_referrer_url(const char* value); + void set_obsolete_referrer_url(const char* value, size_t size); + std::string* mutable_obsolete_referrer_url(); + 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; + 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; + void set_obsolete_hash_prefix(const std::string& value); + void set_obsolete_hash_prefix(std::string&& value); + void set_obsolete_hash_prefix(const char* value); + void set_obsolete_hash_prefix(const void* value, size_t size); + std::string* mutable_obsolete_hash_prefix(); + 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; + 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; + void set_model_filename(const std::string& value); + void set_model_filename(std::string&& value); + void set_model_filename(const char* value); + void set_model_filename(const char* value, size_t size); + std::string* mutable_model_filename(); + std::string* release_model_filename(); + void set_allocated_model_filename(std::string* model_filename); + private: + const std::string& _internal_model_filename() const; + 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; + ::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: + + // 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(); + ::PROTOBUF_NAMESPACE_ID::int32 model_version() const; + void set_model_version(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_model_version() const; + void _internal_set_model_version(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientPhishingRequest) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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< ::PROTOBUF_NAMESPACE_ID::uint32 > 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_; + ::PROTOBUF_NAMESPACE_ID::int32 model_version_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientPhishingResponse : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientPhishingResponse) */ { + public: + ClientPhishingResponse(); + virtual ~ClientPhishingResponse(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientPhishingResponse& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientPhishingResponse* New() const final { + return CreateMaybeMessage<ClientPhishingResponse>(nullptr); + } + + ClientPhishingResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientPhishingResponse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientPhishingResponse"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientMalwareRequest_UrlInfo : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientMalwareRequest.UrlInfo) */ { + public: + ClientMalwareRequest_UrlInfo(); + virtual ~ClientMalwareRequest_UrlInfo(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientMalwareRequest_UrlInfo& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientMalwareRequest_UrlInfo* New() const final { + return CreateMaybeMessage<ClientMalwareRequest_UrlInfo>(nullptr); + } + + ClientMalwareRequest_UrlInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientMalwareRequest_UrlInfo* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientMalwareRequest.UrlInfo"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_ip(const std::string& value); + void set_ip(std::string&& value); + void set_ip(const char* value); + void set_ip(const char* value, size_t size); + std::string* mutable_ip(); + std::string* release_ip(); + void set_allocated_ip(std::string* ip); + private: + const std::string& _internal_ip() const; + 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; + void set_url(const std::string& value); + void set_url(std::string&& value); + void set_url(const char* value); + void set_url(const char* value, size_t size); + std::string* mutable_url(); + std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + 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; + void set_method(const std::string& value); + void set_method(std::string&& value); + void set_method(const char* value); + void set_method(const char* value, size_t size); + std::string* mutable_method(); + std::string* release_method(); + void set_allocated_method(std::string* method); + private: + const std::string& _internal_method() const; + 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; + void set_referrer(const std::string& value); + void set_referrer(std::string&& value); + void set_referrer(const char* value); + void set_referrer(const char* value, size_t size); + std::string* mutable_referrer(); + std::string* release_referrer(); + void set_allocated_referrer(std::string* referrer); + private: + const std::string& _internal_referrer() const; + 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(); + ::PROTOBUF_NAMESPACE_ID::int32 resource_type() const; + void set_resource_type(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_resource_type() const; + void _internal_set_resource_type(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientMalwareRequest.UrlInfo) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int32 resource_type_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientMalwareRequest : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientMalwareRequest) */ { + public: + ClientMalwareRequest(); + virtual ~ClientMalwareRequest(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientMalwareRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientMalwareRequest* New() const final { + return CreateMaybeMessage<ClientMalwareRequest>(nullptr); + } + + ClientMalwareRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientMalwareRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientMalwareRequest"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_url(const std::string& value); + void set_url(std::string&& value); + void set_url(const char* value); + void set_url(const char* value, size_t size); + std::string* mutable_url(); + std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + 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; + void set_referrer_url(const std::string& value); + void set_referrer_url(std::string&& value); + void set_referrer_url(const char* value); + void set_referrer_url(const char* value, size_t size); + std::string* mutable_referrer_url(); + std::string* release_referrer_url(); + void set_allocated_referrer_url(std::string* referrer_url); + private: + const std::string& _internal_referrer_url() const; + 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; + ::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: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientMalwareRequest) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class LoginReputationClientRequest_Frame_Form : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.LoginReputationClientRequest.Frame.Form) */ { + public: + LoginReputationClientRequest_Frame_Form(); + virtual ~LoginReputationClientRequest_Frame_Form(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const LoginReputationClientRequest_Frame_Form& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline LoginReputationClientRequest_Frame_Form* New() const final { + return CreateMaybeMessage<LoginReputationClientRequest_Frame_Form>(nullptr); + } + + LoginReputationClientRequest_Frame_Form* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(LoginReputationClientRequest_Frame_Form* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.LoginReputationClientRequest.Frame.Form"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_action_url(const std::string& value); + void set_action_url(std::string&& value); + void set_action_url(const char* value); + void set_action_url(const char* value, size_t size); + std::string* mutable_action_url(); + std::string* release_action_url(); + void set_allocated_action_url(std::string* action_url); + private: + const std::string& _internal_action_url() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class LoginReputationClientRequest_Frame : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.LoginReputationClientRequest.Frame) */ { + public: + LoginReputationClientRequest_Frame(); + virtual ~LoginReputationClientRequest_Frame(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const LoginReputationClientRequest_Frame& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline LoginReputationClientRequest_Frame* New() const final { + return CreateMaybeMessage<LoginReputationClientRequest_Frame>(nullptr); + } + + LoginReputationClientRequest_Frame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(LoginReputationClientRequest_Frame* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.LoginReputationClientRequest.Frame"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_url(const std::string& value); + void set_url(std::string&& value); + void set_url(const char* value); + void set_url(const char* value, size_t size); + std::string* mutable_url(); + std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + 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(); + ::PROTOBUF_NAMESPACE_ID::int32 frame_index() const; + void set_frame_index(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_frame_index() const; + void _internal_set_frame_index(::PROTOBUF_NAMESPACE_ID::int32 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(); + ::PROTOBUF_NAMESPACE_ID::int32 parent_frame_index() const; + void set_parent_frame_index(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_parent_frame_index() const; + void _internal_set_parent_frame_index(::PROTOBUF_NAMESPACE_ID::int32 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int32 frame_index_; + ::PROTOBUF_NAMESPACE_ID::int32 parent_frame_index_; + bool has_password_field_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class LoginReputationClientRequest_PasswordReuseEvent : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent) */ { + public: + LoginReputationClientRequest_PasswordReuseEvent(); + virtual ~LoginReputationClientRequest_PasswordReuseEvent(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const LoginReputationClientRequest_PasswordReuseEvent& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline LoginReputationClientRequest_PasswordReuseEvent* New() const final { + return CreateMaybeMessage<LoginReputationClientRequest_PasswordReuseEvent>(nullptr); + } + + LoginReputationClientRequest_PasswordReuseEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(LoginReputationClientRequest_PasswordReuseEvent* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.LoginReputationClientRequest.PasswordReuseEvent"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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(); + ::PROTOBUF_NAMESPACE_ID::int32 frame_id() const; + void set_frame_id(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_frame_id() const; + void _internal_set_frame_id(::PROTOBUF_NAMESPACE_ID::int32 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int32 frame_id_; + bool is_chrome_signin_password_; + int sync_account_type_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class LoginReputationClientRequest : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.LoginReputationClientRequest) */ { + public: + LoginReputationClientRequest(); + virtual ~LoginReputationClientRequest(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const LoginReputationClientRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline LoginReputationClientRequest* New() const final { + return CreateMaybeMessage<LoginReputationClientRequest>(nullptr); + } + + LoginReputationClientRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(LoginReputationClientRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.LoginReputationClientRequest"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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; + void set_page_url(const std::string& value); + void set_page_url(std::string&& value); + void set_page_url(const char* value); + void set_page_url(const char* value, size_t size); + std::string* mutable_page_url(); + std::string* release_page_url(); + void set_allocated_page_url(std::string* page_url); + private: + const std::string& _internal_page_url() const; + 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; + ::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: + + // 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; + ::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: + + // 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(); + ::PROTOBUF_NAMESPACE_ID::int32 stored_verdict_cnt() const; + void set_stored_verdict_cnt(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_stored_verdict_cnt() const; + void _internal_set_stored_verdict_cnt(::PROTOBUF_NAMESPACE_ID::int32 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int32 stored_verdict_cnt_; + bool clicked_through_interstitial_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class LoginReputationClientResponse : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.LoginReputationClientResponse) */ { + public: + LoginReputationClientResponse(); + virtual ~LoginReputationClientResponse(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const LoginReputationClientResponse& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline LoginReputationClientResponse* New() const final { + return CreateMaybeMessage<LoginReputationClientResponse>(nullptr); + } + + LoginReputationClientResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(LoginReputationClientResponse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.LoginReputationClientResponse"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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; + void set_cache_expression(const std::string& value); + void set_cache_expression(std::string&& value); + void set_cache_expression(const char* value); + void set_cache_expression(const char* value, size_t size); + std::string* mutable_cache_expression(); + std::string* release_cache_expression(); + void set_allocated_cache_expression(std::string* cache_expression); + private: + const std::string& _internal_cache_expression() const; + 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; + void set_verdict_token(const std::string& value); + void set_verdict_token(std::string&& value); + void set_verdict_token(const char* value); + void set_verdict_token(const void* value, size_t size); + std::string* mutable_verdict_token(); + std::string* release_verdict_token(); + void set_allocated_verdict_token(std::string* verdict_token); + private: + const std::string& _internal_verdict_token() const; + 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(); + ::PROTOBUF_NAMESPACE_ID::int64 cache_duration_sec() const; + void set_cache_duration_sec(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_cache_duration_sec() const; + void _internal_set_cache_duration_sec(::PROTOBUF_NAMESPACE_ID::int64 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int64 cache_duration_sec_; + int verdict_type_; + bool deprecated_cache_expression_exact_match_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientMalwareResponse : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientMalwareResponse) */ { + public: + ClientMalwareResponse(); + virtual ~ClientMalwareResponse(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientMalwareResponse& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientMalwareResponse* New() const final { + return CreateMaybeMessage<ClientMalwareResponse>(nullptr); + } + + ClientMalwareResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientMalwareResponse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientMalwareResponse"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_bad_ip(const std::string& value); + void set_bad_ip(std::string&& value); + void set_bad_ip(const char* value); + void set_bad_ip(const char* value, size_t size); + std::string* mutable_bad_ip(); + std::string* release_bad_ip(); + void set_allocated_bad_ip(std::string* bad_ip); + private: + const std::string& _internal_bad_ip() const; + 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; + void set_bad_url(const std::string& value); + void set_bad_url(std::string&& value); + void set_bad_url(const char* value); + void set_bad_url(const char* value, size_t size); + std::string* mutable_bad_url(); + std::string* release_bad_url(); + void set_allocated_bad_url(std::string* bad_url); + private: + const std::string& _internal_bad_url() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadRequest_Digests : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.Digests) */ { + public: + ClientDownloadRequest_Digests(); + virtual ~ClientDownloadRequest_Digests(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadRequest_Digests& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadRequest_Digests* New() const final { + return CreateMaybeMessage<ClientDownloadRequest_Digests>(nullptr); + } + + ClientDownloadRequest_Digests* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadRequest_Digests* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadRequest.Digests"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_sha256(const std::string& value); + void set_sha256(std::string&& value); + void set_sha256(const char* value); + void set_sha256(const void* value, size_t size); + std::string* mutable_sha256(); + std::string* release_sha256(); + void set_allocated_sha256(std::string* sha256); + private: + const std::string& _internal_sha256() const; + 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; + void set_sha1(const std::string& value); + void set_sha1(std::string&& value); + void set_sha1(const char* value); + void set_sha1(const void* value, size_t size); + std::string* mutable_sha1(); + std::string* release_sha1(); + void set_allocated_sha1(std::string* sha1); + private: + const std::string& _internal_sha1() const; + 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; + void set_md5(const std::string& value); + void set_md5(std::string&& value); + void set_md5(const char* value); + void set_md5(const void* value, size_t size); + std::string* mutable_md5(); + std::string* release_md5(); + void set_allocated_md5(std::string* md5); + private: + const std::string& _internal_md5() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadRequest_Resource : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.Resource) */ { + public: + ClientDownloadRequest_Resource(); + virtual ~ClientDownloadRequest_Resource(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadRequest_Resource& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadRequest_Resource* New() const final { + return CreateMaybeMessage<ClientDownloadRequest_Resource>(nullptr); + } + + ClientDownloadRequest_Resource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadRequest_Resource* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadRequest.Resource"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_url(const std::string& value); + void set_url(std::string&& value); + void set_url(const char* value); + void set_url(const char* value, size_t size); + std::string* mutable_url(); + std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + 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; + void set_remote_ip(const std::string& value); + void set_remote_ip(std::string&& value); + void set_remote_ip(const char* value); + void set_remote_ip(const void* value, size_t size); + std::string* mutable_remote_ip(); + std::string* release_remote_ip(); + void set_allocated_remote_ip(std::string* remote_ip); + private: + const std::string& _internal_remote_ip() const; + 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; + void set_referrer(const std::string& value); + void set_referrer(std::string&& value); + void set_referrer(const char* value); + void set_referrer(const char* value, size_t size); + std::string* mutable_referrer(); + std::string* release_referrer(); + void set_allocated_referrer(std::string* referrer); + private: + const std::string& _internal_referrer() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadRequest_CertificateChain_Element : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.CertificateChain.Element) */ { + public: + ClientDownloadRequest_CertificateChain_Element(); + virtual ~ClientDownloadRequest_CertificateChain_Element(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadRequest_CertificateChain_Element& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadRequest_CertificateChain_Element* New() const final { + return CreateMaybeMessage<ClientDownloadRequest_CertificateChain_Element>(nullptr); + } + + ClientDownloadRequest_CertificateChain_Element* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadRequest_CertificateChain_Element* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadRequest.CertificateChain.Element"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_certificate(const std::string& value); + void set_certificate(std::string&& value); + void set_certificate(const char* value); + void set_certificate(const void* value, size_t size); + std::string* mutable_certificate(); + std::string* release_certificate(); + void set_allocated_certificate(std::string* certificate); + private: + const std::string& _internal_certificate() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadRequest_CertificateChain : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.CertificateChain) */ { + public: + ClientDownloadRequest_CertificateChain(); + virtual ~ClientDownloadRequest_CertificateChain(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadRequest_CertificateChain& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadRequest_CertificateChain* New() const final { + return CreateMaybeMessage<ClientDownloadRequest_CertificateChain>(nullptr); + } + + ClientDownloadRequest_CertificateChain* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadRequest_CertificateChain* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadRequest.CertificateChain"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element > element_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadRequest_ExtendedAttr : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.ExtendedAttr) */ { + public: + ClientDownloadRequest_ExtendedAttr(); + virtual ~ClientDownloadRequest_ExtendedAttr(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadRequest_ExtendedAttr& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadRequest_ExtendedAttr* New() const final { + return CreateMaybeMessage<ClientDownloadRequest_ExtendedAttr>(nullptr); + } + + ClientDownloadRequest_ExtendedAttr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadRequest_ExtendedAttr* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadRequest.ExtendedAttr"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_key(const std::string& value); + void set_key(std::string&& value); + void set_key(const char* value); + void set_key(const char* value, size_t size); + std::string* mutable_key(); + std::string* release_key(); + void set_allocated_key(std::string* key); + private: + const std::string& _internal_key() const; + 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; + void set_value(const std::string& value); + void set_value(std::string&& value); + void set_value(const char* value); + void set_value(const void* value, size_t size); + std::string* mutable_value(); + std::string* release_value(); + void set_allocated_value(std::string* value); + private: + const std::string& _internal_value() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadRequest_SignatureInfo : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.SignatureInfo) */ { + public: + ClientDownloadRequest_SignatureInfo(); + virtual ~ClientDownloadRequest_SignatureInfo(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadRequest_SignatureInfo& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadRequest_SignatureInfo* New() const final { + return CreateMaybeMessage<ClientDownloadRequest_SignatureInfo>(nullptr); + } + + ClientDownloadRequest_SignatureInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadRequest_SignatureInfo* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadRequest.SignatureInfo"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadRequest_PEImageHeaders_DebugData : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData) */ { + public: + ClientDownloadRequest_PEImageHeaders_DebugData(); + virtual ~ClientDownloadRequest_PEImageHeaders_DebugData(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadRequest_PEImageHeaders_DebugData& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadRequest_PEImageHeaders_DebugData* New() const final { + return CreateMaybeMessage<ClientDownloadRequest_PEImageHeaders_DebugData>(nullptr); + } + + ClientDownloadRequest_PEImageHeaders_DebugData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadRequest_PEImageHeaders_DebugData* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_directory_entry(const std::string& value); + void set_directory_entry(std::string&& value); + void set_directory_entry(const char* value); + void set_directory_entry(const void* value, size_t size); + std::string* mutable_directory_entry(); + std::string* release_directory_entry(); + void set_allocated_directory_entry(std::string* directory_entry); + private: + const std::string& _internal_directory_entry() const; + 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; + void set_raw_data(const std::string& value); + void set_raw_data(std::string&& value); + void set_raw_data(const char* value); + void set_raw_data(const void* value, size_t size); + std::string* mutable_raw_data(); + std::string* release_raw_data(); + void set_allocated_raw_data(std::string* raw_data); + private: + const std::string& _internal_raw_data() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadRequest_PEImageHeaders : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.PEImageHeaders) */ { + public: + ClientDownloadRequest_PEImageHeaders(); + virtual ~ClientDownloadRequest_PEImageHeaders(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadRequest_PEImageHeaders& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadRequest_PEImageHeaders* New() const final { + return CreateMaybeMessage<ClientDownloadRequest_PEImageHeaders>(nullptr); + } + + ClientDownloadRequest_PEImageHeaders* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadRequest_PEImageHeaders* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadRequest.PEImageHeaders"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_dos_header(const std::string& value); + void set_dos_header(std::string&& value); + void set_dos_header(const char* value); + void set_dos_header(const void* value, size_t size); + std::string* mutable_dos_header(); + std::string* release_dos_header(); + void set_allocated_dos_header(std::string* dos_header); + private: + const std::string& _internal_dos_header() const; + 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; + void set_file_header(const std::string& value); + void set_file_header(std::string&& value); + void set_file_header(const char* value); + void set_file_header(const void* value, size_t size); + std::string* mutable_file_header(); + std::string* release_file_header(); + void set_allocated_file_header(std::string* file_header); + private: + const std::string& _internal_file_header() const; + 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; + void set_optional_headers32(const std::string& value); + void set_optional_headers32(std::string&& value); + void set_optional_headers32(const char* value); + void set_optional_headers32(const void* value, size_t size); + std::string* mutable_optional_headers32(); + std::string* release_optional_headers32(); + void set_allocated_optional_headers32(std::string* optional_headers32); + private: + const std::string& _internal_optional_headers32() const; + 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; + void set_optional_headers64(const std::string& value); + void set_optional_headers64(std::string&& value); + void set_optional_headers64(const char* value); + void set_optional_headers64(const void* value, size_t size); + std::string* mutable_optional_headers64(); + std::string* release_optional_headers64(); + void set_allocated_optional_headers64(std::string* optional_headers64); + private: + const std::string& _internal_optional_headers64() const; + 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; + void set_export_section_data(const std::string& value); + void set_export_section_data(std::string&& value); + void set_export_section_data(const char* value); + void set_export_section_data(const void* value, size_t size); + std::string* mutable_export_section_data(); + 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; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadRequest_MachOHeaders_LoadCommand : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand) */ { + public: + ClientDownloadRequest_MachOHeaders_LoadCommand(); + virtual ~ClientDownloadRequest_MachOHeaders_LoadCommand(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadRequest_MachOHeaders_LoadCommand& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadRequest_MachOHeaders_LoadCommand* New() const final { + return CreateMaybeMessage<ClientDownloadRequest_MachOHeaders_LoadCommand>(nullptr); + } + + ClientDownloadRequest_MachOHeaders_LoadCommand* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadRequest_MachOHeaders_LoadCommand* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_command(const std::string& value); + void set_command(std::string&& value); + void set_command(const char* value); + void set_command(const void* value, size_t size); + std::string* mutable_command(); + std::string* release_command(); + void set_allocated_command(std::string* command); + private: + const std::string& _internal_command() const; + 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(); + ::PROTOBUF_NAMESPACE_ID::uint32 command_id() const; + void set_command_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_command_id() const; + void _internal_set_command_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr command_; + ::PROTOBUF_NAMESPACE_ID::uint32 command_id_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadRequest_MachOHeaders : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.MachOHeaders) */ { + public: + ClientDownloadRequest_MachOHeaders(); + virtual ~ClientDownloadRequest_MachOHeaders(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadRequest_MachOHeaders& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadRequest_MachOHeaders* New() const final { + return CreateMaybeMessage<ClientDownloadRequest_MachOHeaders>(nullptr); + } + + ClientDownloadRequest_MachOHeaders* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadRequest_MachOHeaders* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadRequest.MachOHeaders"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_mach_header(const std::string& value); + void set_mach_header(std::string&& value); + void set_mach_header(const char* value); + void set_mach_header(const void* value, size_t size); + std::string* mutable_mach_header(); + std::string* release_mach_header(); + void set_allocated_mach_header(std::string* mach_header); + private: + const std::string& _internal_mach_header() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadRequest_ImageHeaders : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.ImageHeaders) */ { + public: + ClientDownloadRequest_ImageHeaders(); + virtual ~ClientDownloadRequest_ImageHeaders(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadRequest_ImageHeaders& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadRequest_ImageHeaders* New() const final { + return CreateMaybeMessage<ClientDownloadRequest_ImageHeaders>(nullptr); + } + + ClientDownloadRequest_ImageHeaders* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadRequest_ImageHeaders* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadRequest.ImageHeaders"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + ::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: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.ImageHeaders) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadRequest_ArchivedBinary : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest.ArchivedBinary) */ { + public: + ClientDownloadRequest_ArchivedBinary(); + virtual ~ClientDownloadRequest_ArchivedBinary(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadRequest_ArchivedBinary& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadRequest_ArchivedBinary* New() const final { + return CreateMaybeMessage<ClientDownloadRequest_ArchivedBinary>(nullptr); + } + + ClientDownloadRequest_ArchivedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadRequest_ArchivedBinary* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadRequest.ArchivedBinary"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_file_basename(const std::string& value); + void set_file_basename(std::string&& value); + void set_file_basename(const char* value); + void set_file_basename(const char* value, size_t size); + std::string* mutable_file_basename(); + std::string* release_file_basename(); + void set_allocated_file_basename(std::string* file_basename); + private: + const std::string& _internal_file_basename() const; + 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; + ::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: + + // 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; + ::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: + + // 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; + ::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: + + // optional int64 length = 4; + bool has_length() const; + private: + bool _internal_has_length() const; + public: + void clear_length(); + ::PROTOBUF_NAMESPACE_ID::int64 length() const; + void set_length(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_length() const; + void _internal_set_length(::PROTOBUF_NAMESPACE_ID::int64 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int64 length_; + int download_type_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadRequest : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadRequest) */ { + public: + ClientDownloadRequest(); + virtual ~ClientDownloadRequest(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadRequest* New() const final { + return CreateMaybeMessage<ClientDownloadRequest>(nullptr); + } + + ClientDownloadRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadRequest"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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(const std::string& 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, + kDEPRECATEDDownloadAttributionFinchEnabledFieldNumber = 39, + kDownloadTypeFieldNumber = 10, + kUserInitiatedFieldNumber = 6, + kArchiveValidFieldNumber = 26, + kSkippedUrlWhitelistFieldNumber = 28, + kSkippedCertificateWhitelistFieldNumber = 31, + }; + // 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; + void set_url(const std::string& value); + void set_url(std::string&& value); + void set_url(const char* value); + void set_url(const char* value, size_t size); + std::string* mutable_url(); + std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + 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; + void set_file_basename(const std::string& value); + void set_file_basename(std::string&& value); + void set_file_basename(const char* value); + void set_file_basename(const char* value, size_t size); + std::string* mutable_file_basename(); + std::string* release_file_basename(); + void set_allocated_file_basename(std::string* file_basename); + private: + const std::string& _internal_file_basename() const; + 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; + void set_locale(const std::string& value); + void set_locale(std::string&& value); + void set_locale(const char* value); + void set_locale(const char* value, size_t size); + std::string* mutable_locale(); + std::string* release_locale(); + void set_allocated_locale(std::string* locale); + private: + const std::string& _internal_locale() const; + 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; + void set_udif_code_signature(const std::string& value); + void set_udif_code_signature(std::string&& value); + void set_udif_code_signature(const char* value); + void set_udif_code_signature(const void* value, size_t size); + std::string* mutable_udif_code_signature(); + 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; + 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; + ::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: + + // 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; + ::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: + + // 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; + ::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: + + // 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; + ::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: + + // required int64 length = 3; + bool has_length() const; + private: + bool _internal_has_length() const; + public: + void clear_length(); + ::PROTOBUF_NAMESPACE_ID::int64 length() const; + void set_length(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_length() const; + void _internal_set_length(::PROTOBUF_NAMESPACE_ID::int64 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: + + // 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: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest) + private: + class _Internal; + + // helper for ByteSizeLong() + size_t RequiredFieldsByteSizeFallback() const; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int64 length_; + bool deprecated_download_attribution_finch_enabled_; + int download_type_; + bool user_initiated_; + bool archive_valid_; + bool skipped_url_whitelist_; + bool skipped_certificate_whitelist_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ReferrerChainEntry_ServerRedirect : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ReferrerChainEntry.ServerRedirect) */ { + public: + ReferrerChainEntry_ServerRedirect(); + virtual ~ReferrerChainEntry_ServerRedirect(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ReferrerChainEntry_ServerRedirect& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReferrerChainEntry_ServerRedirect* New() const final { + return CreateMaybeMessage<ReferrerChainEntry_ServerRedirect>(nullptr); + } + + ReferrerChainEntry_ServerRedirect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ReferrerChainEntry_ServerRedirect* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ReferrerChainEntry.ServerRedirect"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_url(const std::string& value); + void set_url(std::string&& value); + void set_url(const char* value); + void set_url(const char* value, size_t size); + std::string* mutable_url(); + std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ReferrerChainEntry : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ReferrerChainEntry) */ { + public: + ReferrerChainEntry(); + virtual ~ReferrerChainEntry(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ReferrerChainEntry& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReferrerChainEntry* New() const final { + return CreateMaybeMessage<ReferrerChainEntry>(nullptr); + } + + ReferrerChainEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ReferrerChainEntry* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ReferrerChainEntry"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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; + void set_url(const std::string& value); + void set_url(std::string&& value); + void set_url(const char* value); + void set_url(const char* value, size_t size); + std::string* mutable_url(); + std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + 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; + void set_referrer_url(const std::string& value); + void set_referrer_url(std::string&& value); + void set_referrer_url(const char* value); + void set_referrer_url(const char* value, size_t size); + std::string* mutable_referrer_url(); + std::string* release_referrer_url(); + void set_allocated_referrer_url(std::string* referrer_url); + private: + const std::string& _internal_referrer_url() const; + 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; + void set_referrer_main_frame_url(const std::string& value); + void set_referrer_main_frame_url(std::string&& value); + void set_referrer_main_frame_url(const char* value); + void set_referrer_main_frame_url(const char* value, size_t size); + std::string* mutable_referrer_main_frame_url(); + 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; + 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; + void set_main_frame_url(const std::string& value); + void set_main_frame_url(std::string&& value); + void set_main_frame_url(const char* value); + void set_main_frame_url(const char* value, size_t size); + std::string* mutable_main_frame_url(); + 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; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadResponse_MoreInfo : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadResponse.MoreInfo) */ { + public: + ClientDownloadResponse_MoreInfo(); + virtual ~ClientDownloadResponse_MoreInfo(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadResponse_MoreInfo& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadResponse_MoreInfo* New() const final { + return CreateMaybeMessage<ClientDownloadResponse_MoreInfo>(nullptr); + } + + ClientDownloadResponse_MoreInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadResponse_MoreInfo* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadResponse.MoreInfo"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_description(const std::string& value); + void set_description(std::string&& value); + void set_description(const char* value); + void set_description(const char* value, size_t size); + std::string* mutable_description(); + std::string* release_description(); + void set_allocated_description(std::string* description); + private: + const std::string& _internal_description() const; + 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; + void set_url(const std::string& value); + void set_url(std::string&& value); + void set_url(const char* value); + void set_url(const char* value, size_t size); + std::string* mutable_url(); + std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadResponse : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadResponse) */ { + public: + ClientDownloadResponse(); + virtual ~ClientDownloadResponse(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadResponse& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadResponse* New() const final { + return CreateMaybeMessage<ClientDownloadResponse>(nullptr); + } + + ClientDownloadResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadResponse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadResponse"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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; + void set_token(const std::string& value); + void set_token(std::string&& value); + void set_token(const char* value); + void set_token(const void* value, size_t size); + std::string* mutable_token(); + std::string* release_token(); + void set_allocated_token(std::string* token); + private: + const std::string& _internal_token() const; + 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; + ::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: + + // 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadReport_UserInformation : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadReport.UserInformation) */ { + public: + ClientDownloadReport_UserInformation(); + virtual ~ClientDownloadReport_UserInformation(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadReport_UserInformation& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadReport_UserInformation* New() const final { + return CreateMaybeMessage<ClientDownloadReport_UserInformation>(nullptr); + } + + ClientDownloadReport_UserInformation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadReport_UserInformation* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadReport.UserInformation"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_email(const std::string& value); + void set_email(std::string&& value); + void set_email(const char* value); + void set_email(const char* value, size_t size); + std::string* mutable_email(); + std::string* release_email(); + void set_allocated_email(std::string* email); + private: + const std::string& _internal_email() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr email_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientDownloadReport : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientDownloadReport) */ { + public: + ClientDownloadReport(); + virtual ~ClientDownloadReport(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientDownloadReport& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientDownloadReport* New() const final { + return CreateMaybeMessage<ClientDownloadReport>(nullptr); + } + + ClientDownloadReport* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientDownloadReport* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientDownloadReport"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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; + void set_comment(const std::string& value); + void set_comment(std::string&& value); + void set_comment(const char* value); + void set_comment(const void* value, size_t size); + std::string* mutable_comment(); + std::string* release_comment(); + void set_allocated_comment(std::string* comment); + private: + const std::string& _internal_comment() const; + 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; + ::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: + + // 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; + ::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: + + // 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; + ::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: + + // 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientUploadResponse : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientUploadResponse) */ { + public: + ClientUploadResponse(); + virtual ~ClientUploadResponse(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientUploadResponse& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientUploadResponse* New() const final { + return CreateMaybeMessage<ClientUploadResponse>(nullptr); + } + + ClientUploadResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientUploadResponse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientUploadResponse"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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; + void set_permalink(const std::string& value); + void set_permalink(std::string&& value); + void set_permalink(const char* value); + void set_permalink(const char* value, size_t size); + std::string* mutable_permalink(); + std::string* release_permalink(); + void set_allocated_permalink(std::string* permalink); + private: + const std::string& _internal_permalink() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr permalink_; + int status_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_IncidentData_TrackedPreferenceIncident : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident) */ { + public: + ClientIncidentReport_IncidentData_TrackedPreferenceIncident(); + virtual ~ClientIncidentReport_IncidentData_TrackedPreferenceIncident(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_IncidentData_TrackedPreferenceIncident* New() const final { + return CreateMaybeMessage<ClientIncidentReport_IncidentData_TrackedPreferenceIncident>(nullptr); + } + + ClientIncidentReport_IncidentData_TrackedPreferenceIncident* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_IncidentData_TrackedPreferenceIncident* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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; + void set_path(const std::string& value); + void set_path(std::string&& value); + void set_path(const char* value); + void set_path(const char* value, size_t size); + std::string* mutable_path(); + std::string* release_path(); + void set_allocated_path(std::string* path); + private: + const std::string& _internal_path() const; + 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; + void set_atomic_value(const std::string& value); + void set_atomic_value(std::string&& value); + void set_atomic_value(const char* value); + void set_atomic_value(const char* value, size_t size); + std::string* mutable_atomic_value(); + std::string* release_atomic_value(); + void set_allocated_atomic_value(std::string* atomic_value); + private: + const std::string& _internal_atomic_value() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile) */ { + public: + ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile(); + virtual ~ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* New() const final { + return CreateMaybeMessage<ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile>(nullptr); + } + + ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_relative_path(const std::string& value); + void set_relative_path(std::string&& value); + void set_relative_path(const char* value); + void set_relative_path(const char* value, size_t size); + std::string* mutable_relative_path(); + std::string* release_relative_path(); + void set_allocated_relative_path(std::string* relative_path); + private: + const std::string& _internal_relative_path() const; + 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; + ::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: + + // 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; + ::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: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_IncidentData_BinaryIntegrityIncident : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident) */ { + public: + ClientIncidentReport_IncidentData_BinaryIntegrityIncident(); + virtual ~ClientIncidentReport_IncidentData_BinaryIntegrityIncident(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_IncidentData_BinaryIntegrityIncident* New() const final { + return CreateMaybeMessage<ClientIncidentReport_IncidentData_BinaryIntegrityIncident>(nullptr); + } + + ClientIncidentReport_IncidentData_BinaryIntegrityIncident* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_file_basename(const std::string& value); + void set_file_basename(std::string&& value); + void set_file_basename(const char* value); + void set_file_basename(const char* value, size_t size); + std::string* mutable_file_basename(); + std::string* release_file_basename(); + void set_allocated_file_basename(std::string* file_basename); + private: + const std::string& _internal_file_basename() const; + 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; + ::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: + + // 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; + ::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: + + // optional int32 sec_error = 4; + bool has_sec_error() const; + private: + bool _internal_has_sec_error() const; + public: + void clear_sec_error(); + ::PROTOBUF_NAMESPACE_ID::int32 sec_error() const; + void set_sec_error(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_sec_error() const; + void _internal_set_sec_error(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int32 sec_error_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_IncidentData_ResourceRequestIncident : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident) */ { + public: + ClientIncidentReport_IncidentData_ResourceRequestIncident(); + virtual ~ClientIncidentReport_IncidentData_ResourceRequestIncident(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_IncidentData_ResourceRequestIncident& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_IncidentData_ResourceRequestIncident* New() const final { + return CreateMaybeMessage<ClientIncidentReport_IncidentData_ResourceRequestIncident>(nullptr); + } + + ClientIncidentReport_IncidentData_ResourceRequestIncident* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_IncidentData_ResourceRequestIncident* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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; + void set_digest(const std::string& value); + void set_digest(std::string&& value); + void set_digest(const char* value); + void set_digest(const void* value, size_t size); + std::string* mutable_digest(); + std::string* release_digest(); + void set_allocated_digest(std::string* digest); + private: + const std::string& _internal_digest() const; + 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; + void set_origin(const std::string& value); + void set_origin(std::string&& value); + void set_origin(const char* value); + void set_origin(const char* value, size_t size); + std::string* mutable_origin(); + std::string* release_origin(); + void set_allocated_origin(std::string* origin); + private: + const std::string& _internal_origin() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_IncidentData : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.IncidentData) */ { + public: + ClientIncidentReport_IncidentData(); + virtual ~ClientIncidentReport_IncidentData(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_IncidentData& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_IncidentData* New() const final { + return CreateMaybeMessage<ClientIncidentReport_IncidentData>(nullptr); + } + + ClientIncidentReport_IncidentData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_IncidentData* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.IncidentData"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + ::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: + + // 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; + ::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: + + // 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; + ::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: + + // 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(); + ::PROTOBUF_NAMESPACE_ID::int64 incident_time_msec() const; + void set_incident_time_msec(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_incident_time_msec() const; + void _internal_set_incident_time_msec(::PROTOBUF_NAMESPACE_ID::int64 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int64 incident_time_msec_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_DownloadDetails : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.DownloadDetails) */ { + public: + ClientIncidentReport_DownloadDetails(); + virtual ~ClientIncidentReport_DownloadDetails(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_DownloadDetails& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_DownloadDetails* New() const final { + return CreateMaybeMessage<ClientIncidentReport_DownloadDetails>(nullptr); + } + + ClientIncidentReport_DownloadDetails* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_DownloadDetails* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.DownloadDetails"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_token(const std::string& value); + void set_token(std::string&& value); + void set_token(const char* value); + void set_token(const void* value, size_t size); + std::string* mutable_token(); + std::string* release_token(); + void set_allocated_token(std::string* token); + private: + const std::string& _internal_token() const; + 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; + ::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: + + // 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(); + ::PROTOBUF_NAMESPACE_ID::int64 download_time_msec() const; + void set_download_time_msec(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_download_time_msec() const; + void _internal_set_download_time_msec(::PROTOBUF_NAMESPACE_ID::int64 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(); + ::PROTOBUF_NAMESPACE_ID::int64 open_time_msec() const; + void set_open_time_msec(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_open_time_msec() const; + void _internal_set_open_time_msec(::PROTOBUF_NAMESPACE_ID::int64 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.DownloadDetails) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int64 download_time_msec_; + ::PROTOBUF_NAMESPACE_ID::int64 open_time_msec_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_EnvironmentData_OS_RegistryValue : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue) */ { + public: + ClientIncidentReport_EnvironmentData_OS_RegistryValue(); + virtual ~ClientIncidentReport_EnvironmentData_OS_RegistryValue(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_EnvironmentData_OS_RegistryValue& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_EnvironmentData_OS_RegistryValue* New() const final { + return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_OS_RegistryValue>(nullptr); + } + + ClientIncidentReport_EnvironmentData_OS_RegistryValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_EnvironmentData_OS_RegistryValue* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + 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; + void set_data(const std::string& value); + void set_data(std::string&& value); + void set_data(const char* value); + void set_data(const void* value, size_t size); + std::string* mutable_data(); + std::string* release_data(); + void set_allocated_data(std::string* data); + private: + const std::string& _internal_data() const; + 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(); + ::PROTOBUF_NAMESPACE_ID::uint32 type() const; + void set_type(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type() const; + void _internal_set_type(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_EnvironmentData_OS_RegistryKey : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey) */ { + public: + ClientIncidentReport_EnvironmentData_OS_RegistryKey(); + virtual ~ClientIncidentReport_EnvironmentData_OS_RegistryKey(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_EnvironmentData_OS_RegistryKey& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_EnvironmentData_OS_RegistryKey* New() const final { + return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_OS_RegistryKey>(nullptr); + } + + ClientIncidentReport_EnvironmentData_OS_RegistryKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_EnvironmentData_OS_RegistryKey* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_EnvironmentData_OS : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.OS) */ { + public: + ClientIncidentReport_EnvironmentData_OS(); + virtual ~ClientIncidentReport_EnvironmentData_OS(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_EnvironmentData_OS& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_EnvironmentData_OS* New() const final { + return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_OS>(nullptr); + } + + ClientIncidentReport_EnvironmentData_OS* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_EnvironmentData_OS* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.EnvironmentData.OS"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_os_name(const std::string& value); + void set_os_name(std::string&& value); + void set_os_name(const char* value); + void set_os_name(const char* value, size_t size); + std::string* mutable_os_name(); + std::string* release_os_name(); + void set_allocated_os_name(std::string* os_name); + private: + const std::string& _internal_os_name() const; + 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; + void set_os_version(const std::string& value); + void set_os_version(std::string&& value); + void set_os_version(const char* value); + void set_os_version(const char* value, size_t size); + std::string* mutable_os_version(); + std::string* release_os_version(); + void set_allocated_os_version(std::string* os_version); + private: + const std::string& _internal_os_version() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_EnvironmentData_Machine : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Machine) */ { + public: + ClientIncidentReport_EnvironmentData_Machine(); + virtual ~ClientIncidentReport_EnvironmentData_Machine(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_EnvironmentData_Machine& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_EnvironmentData_Machine* New() const final { + return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Machine>(nullptr); + } + + ClientIncidentReport_EnvironmentData_Machine* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_EnvironmentData_Machine* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Machine"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_cpu_architecture(const std::string& value); + void set_cpu_architecture(std::string&& value); + void set_cpu_architecture(const char* value); + void set_cpu_architecture(const char* value, size_t size); + std::string* mutable_cpu_architecture(); + std::string* release_cpu_architecture(); + void set_allocated_cpu_architecture(std::string* cpu_architecture); + private: + const std::string& _internal_cpu_architecture() const; + 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; + void set_cpu_vendor(const std::string& value); + void set_cpu_vendor(std::string&& value); + void set_cpu_vendor(const char* value); + void set_cpu_vendor(const char* value, size_t size); + std::string* mutable_cpu_vendor(); + std::string* release_cpu_vendor(); + void set_allocated_cpu_vendor(std::string* cpu_vendor); + private: + const std::string& _internal_cpu_vendor() const; + 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(); + ::PROTOBUF_NAMESPACE_ID::uint32 cpuid() const; + void set_cpuid(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_cpuid() const; + void _internal_set_cpuid(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Machine) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::uint32 cpuid_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_EnvironmentData_Process_Patch : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch) */ { + public: + ClientIncidentReport_EnvironmentData_Process_Patch(); + virtual ~ClientIncidentReport_EnvironmentData_Process_Patch(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_EnvironmentData_Process_Patch& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_EnvironmentData_Process_Patch* New() const final { + return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Process_Patch>(nullptr); + } + + ClientIncidentReport_EnvironmentData_Process_Patch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_EnvironmentData_Process_Patch* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_function(const std::string& value); + void set_function(std::string&& value); + void set_function(const char* value); + void set_function(const char* value, size_t size); + std::string* mutable_function(); + std::string* release_function(); + void set_allocated_function(std::string* function); + private: + const std::string& _internal_function() const; + 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; + void set_target_dll(const std::string& value); + void set_target_dll(std::string&& value); + void set_target_dll(const char* value); + void set_target_dll(const char* value, size_t size); + std::string* mutable_target_dll(); + std::string* release_target_dll(); + void set_allocated_target_dll(std::string* target_dll); + private: + const std::string& _internal_target_dll() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_EnvironmentData_Process_NetworkProvider : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider) */ { + public: + ClientIncidentReport_EnvironmentData_Process_NetworkProvider(); + virtual ~ClientIncidentReport_EnvironmentData_Process_NetworkProvider(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_EnvironmentData_Process_NetworkProvider* New() const final { + return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Process_NetworkProvider>(nullptr); + } + + ClientIncidentReport_EnvironmentData_Process_NetworkProvider* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_EnvironmentData_Process_NetworkProvider* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_EnvironmentData_Process_Dll : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll) */ { + public: + ClientIncidentReport_EnvironmentData_Process_Dll(); + virtual ~ClientIncidentReport_EnvironmentData_Process_Dll(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_EnvironmentData_Process_Dll& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_EnvironmentData_Process_Dll* New() const final { + return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Process_Dll>(nullptr); + } + + ClientIncidentReport_EnvironmentData_Process_Dll* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_EnvironmentData_Process_Dll* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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; + void set_path(const std::string& value); + void set_path(std::string&& value); + void set_path(const char* value); + void set_path(const char* value, size_t size); + std::string* mutable_path(); + std::string* release_path(); + void set_allocated_path(std::string* path); + private: + const std::string& _internal_path() const; + 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; + ::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: + + // optional uint64 base_address = 2; + bool has_base_address() const; + private: + bool _internal_has_base_address() const; + public: + void clear_base_address(); + ::PROTOBUF_NAMESPACE_ID::uint64 base_address() const; + void set_base_address(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_base_address() const; + void _internal_set_base_address(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // optional uint32 length = 3; + bool has_length() const; + private: + bool _internal_has_length() const; + public: + void clear_length(); + ::PROTOBUF_NAMESPACE_ID::uint32 length() const; + void set_length(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_length() const; + void _internal_set_length(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::uint64 base_address_; + ::PROTOBUF_NAMESPACE_ID::uint32 length_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification) */ { + public: + ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification(); + virtual ~ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* New() const final { + return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification>(nullptr); + } + + ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_modified_bytes(const std::string& value); + void set_modified_bytes(std::string&& value); + void set_modified_bytes(const char* value); + void set_modified_bytes(const void* value, size_t size); + std::string* mutable_modified_bytes(); + std::string* release_modified_bytes(); + void set_allocated_modified_bytes(std::string* modified_bytes); + private: + const std::string& _internal_modified_bytes() const; + 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; + void set_export_name(const std::string& value); + void set_export_name(std::string&& value); + void set_export_name(const char* value); + void set_export_name(const char* value, size_t size); + std::string* mutable_export_name(); + std::string* release_export_name(); + void set_allocated_export_name(std::string* export_name); + private: + const std::string& _internal_export_name() const; + 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(); + ::PROTOBUF_NAMESPACE_ID::uint32 file_offset() const; + void set_file_offset(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_file_offset() const; + void _internal_set_file_offset(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // optional int32 byte_count = 2; + bool has_byte_count() const; + private: + bool _internal_has_byte_count() const; + public: + void clear_byte_count(); + ::PROTOBUF_NAMESPACE_ID::int32 byte_count() const; + void set_byte_count(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_byte_count() const; + void _internal_set_byte_count(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::uint32 file_offset_; + ::PROTOBUF_NAMESPACE_ID::int32 byte_count_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_EnvironmentData_Process_ModuleState : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState) */ { + public: + ClientIncidentReport_EnvironmentData_Process_ModuleState(); + virtual ~ClientIncidentReport_EnvironmentData_Process_ModuleState(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_EnvironmentData_Process_ModuleState& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_EnvironmentData_Process_ModuleState* New() const final { + return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Process_ModuleState>(nullptr); + } + + ClientIncidentReport_EnvironmentData_Process_ModuleState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_EnvironmentData_Process_ModuleState* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_EnvironmentData_Process : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData.Process) */ { + public: + ClientIncidentReport_EnvironmentData_Process(); + virtual ~ClientIncidentReport_EnvironmentData_Process(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_EnvironmentData_Process& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_EnvironmentData_Process* New() const final { + return CreateMaybeMessage<ClientIncidentReport_EnvironmentData_Process>(nullptr); + } + + ClientIncidentReport_EnvironmentData_Process* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_EnvironmentData_Process* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.EnvironmentData.Process"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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; + void set_version(const std::string& value); + void set_version(std::string&& value); + void set_version(const char* value); + void set_version(const char* value, size_t size); + std::string* mutable_version(); + std::string* release_version(); + void set_allocated_version(std::string* version); + private: + const std::string& _internal_version() const; + 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(); + ::PROTOBUF_NAMESPACE_ID::int64 uptime_msec() const; + void set_uptime_msec(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_uptime_msec() const; + void _internal_set_uptime_msec(::PROTOBUF_NAMESPACE_ID::int64 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int64 uptime_msec_; + int chrome_update_channel_; + bool metrics_consent_; + bool obsolete_extended_consent_; + bool obsolete_field_trial_participant_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_EnvironmentData : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.EnvironmentData) */ { + public: + ClientIncidentReport_EnvironmentData(); + virtual ~ClientIncidentReport_EnvironmentData(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_EnvironmentData& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_EnvironmentData* New() const final { + return CreateMaybeMessage<ClientIncidentReport_EnvironmentData>(nullptr); + } + + ClientIncidentReport_EnvironmentData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_EnvironmentData* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.EnvironmentData"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + ::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: + + // 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; + ::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: + + // 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; + ::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: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_ExtensionData_ExtensionInfo : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo) */ { + public: + ClientIncidentReport_ExtensionData_ExtensionInfo(); + virtual ~ClientIncidentReport_ExtensionData_ExtensionInfo(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_ExtensionData_ExtensionInfo& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_ExtensionData_ExtensionInfo* New() const final { + return CreateMaybeMessage<ClientIncidentReport_ExtensionData_ExtensionInfo>(nullptr); + } + + ClientIncidentReport_ExtensionData_ExtensionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_ExtensionData_ExtensionInfo* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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; + void set_id(const std::string& value); + void set_id(std::string&& value); + void set_id(const char* value); + void set_id(const char* value, size_t size); + std::string* mutable_id(); + std::string* release_id(); + void set_allocated_id(std::string* id); + private: + const std::string& _internal_id() const; + 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; + void set_version(const std::string& value); + void set_version(std::string&& value); + void set_version(const char* value); + void set_version(const char* value, size_t size); + std::string* mutable_version(); + std::string* release_version(); + void set_allocated_version(std::string* version); + private: + const std::string& _internal_version() const; + 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; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + 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; + void set_description(const std::string& value); + void set_description(std::string&& value); + void set_description(const char* value); + void set_description(const char* value, size_t size); + std::string* mutable_description(); + std::string* release_description(); + void set_allocated_description(std::string* description); + private: + const std::string& _internal_description() const; + 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; + void set_update_url(const std::string& value); + void set_update_url(std::string&& value); + void set_update_url(const char* value); + void set_update_url(const char* value, size_t size); + std::string* mutable_update_url(); + std::string* release_update_url(); + void set_allocated_update_url(std::string* update_url); + private: + const std::string& _internal_update_url() const; + 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; + void set_manifest(const std::string& value); + void set_manifest(std::string&& value); + void set_manifest(const char* value); + void set_manifest(const char* value, size_t size); + std::string* mutable_manifest(); + std::string* release_manifest(); + void set_allocated_manifest(std::string* manifest); + private: + const std::string& _internal_manifest() const; + 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(); + ::PROTOBUF_NAMESPACE_ID::int32 type() const; + void set_type(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_type() const; + void _internal_set_type(::PROTOBUF_NAMESPACE_ID::int32 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(); + ::PROTOBUF_NAMESPACE_ID::int64 install_time_msec() const; + void set_install_time_msec(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_install_time_msec() const; + void _internal_set_install_time_msec(::PROTOBUF_NAMESPACE_ID::int64 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(); + ::PROTOBUF_NAMESPACE_ID::int32 manifest_location_type() const; + void set_manifest_location_type(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_manifest_location_type() const; + void _internal_set_manifest_location_type(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int32 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_; + ::PROTOBUF_NAMESPACE_ID::int64 install_time_msec_; + bool may_be_untrusted_; + ::PROTOBUF_NAMESPACE_ID::int32 manifest_location_type_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_ExtensionData : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.ExtensionData) */ { + public: + ClientIncidentReport_ExtensionData(); + virtual ~ClientIncidentReport_ExtensionData(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_ExtensionData& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_ExtensionData* New() const final { + return CreateMaybeMessage<ClientIncidentReport_ExtensionData>(nullptr); + } + + ClientIncidentReport_ExtensionData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_ExtensionData* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.ExtensionData"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + ::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: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.ExtensionData) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* last_installed_extension_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport_NonBinaryDownloadDetails : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails) */ { + public: + ClientIncidentReport_NonBinaryDownloadDetails(); + virtual ~ClientIncidentReport_NonBinaryDownloadDetails(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport_NonBinaryDownloadDetails& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport_NonBinaryDownloadDetails* New() const final { + return CreateMaybeMessage<ClientIncidentReport_NonBinaryDownloadDetails>(nullptr); + } + + ClientIncidentReport_NonBinaryDownloadDetails* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport_NonBinaryDownloadDetails* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_file_type(const std::string& value); + void set_file_type(std::string&& value); + void set_file_type(const char* value); + void set_file_type(const char* value, size_t size); + std::string* mutable_file_type(); + std::string* release_file_type(); + void set_allocated_file_type(std::string* file_type); + private: + const std::string& _internal_file_type() const; + 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; + void set_url_spec_sha256(const std::string& value); + void set_url_spec_sha256(std::string&& value); + void set_url_spec_sha256(const char* value); + void set_url_spec_sha256(const void* value, size_t size); + std::string* mutable_url_spec_sha256(); + 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; + 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; + void set_host(const std::string& value); + void set_host(std::string&& value); + void set_host(const char* value); + void set_host(const char* value, size_t size); + std::string* mutable_host(); + std::string* release_host(); + void set_allocated_host(std::string* host); + private: + const std::string& _internal_host() const; + 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(); + ::PROTOBUF_NAMESPACE_ID::int64 length() const; + void set_length(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_length() const; + void _internal_set_length(::PROTOBUF_NAMESPACE_ID::int64 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int64 length_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentReport : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentReport) */ { + public: + ClientIncidentReport(); + virtual ~ClientIncidentReport(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentReport& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentReport* New() const final { + return CreateMaybeMessage<ClientIncidentReport>(nullptr); + } + + ClientIncidentReport* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentReport* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentReport"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + ::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: + + // 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; + ::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: + + // 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; + ::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: + + // 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; + ::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: + + // 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; + ::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: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentResponse_EnvironmentRequest : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentResponse.EnvironmentRequest) */ { + public: + ClientIncidentResponse_EnvironmentRequest(); + virtual ~ClientIncidentResponse_EnvironmentRequest(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentResponse_EnvironmentRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentResponse_EnvironmentRequest* New() const final { + return CreateMaybeMessage<ClientIncidentResponse_EnvironmentRequest>(nullptr); + } + + ClientIncidentResponse_EnvironmentRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentResponse_EnvironmentRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentResponse.EnvironmentRequest"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(); + ::PROTOBUF_NAMESPACE_ID::int32 dll_index() const; + void set_dll_index(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_dll_index() const; + void _internal_set_dll_index(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentResponse.EnvironmentRequest) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::int32 dll_index_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientIncidentResponse : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientIncidentResponse) */ { + public: + ClientIncidentResponse(); + virtual ~ClientIncidentResponse(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientIncidentResponse& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientIncidentResponse* New() const final { + return CreateMaybeMessage<ClientIncidentResponse>(nullptr); + } + + ClientIncidentResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientIncidentResponse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientIncidentResponse"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_token(const std::string& value); + void set_token(std::string&& value); + void set_token(const char* value); + void set_token(const void* value, size_t size); + std::string* mutable_token(); + std::string* release_token(); + void set_allocated_token(std::string* token); + private: + const std::string& _internal_token() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class DownloadMetadata : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.DownloadMetadata) */ { + public: + DownloadMetadata(); + virtual ~DownloadMetadata(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const DownloadMetadata& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DownloadMetadata* New() const final { + return CreateMaybeMessage<DownloadMetadata>(nullptr); + } + + DownloadMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(DownloadMetadata* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.DownloadMetadata"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + ::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: + + // optional uint32 download_id = 1; + bool has_download_id() const; + private: + bool _internal_has_download_id() const; + public: + void clear_download_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 download_id() const; + void set_download_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_download_id() const; + void _internal_set_download_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.DownloadMetadata) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::safe_browsing::ClientIncidentReport_DownloadDetails* download_; + ::PROTOBUF_NAMESPACE_ID::uint32 download_id_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientSafeBrowsingReportRequest_HTTPHeader : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader) */ { + public: + ClientSafeBrowsingReportRequest_HTTPHeader(); + virtual ~ClientSafeBrowsingReportRequest_HTTPHeader(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientSafeBrowsingReportRequest_HTTPHeader& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientSafeBrowsingReportRequest_HTTPHeader* New() const final { + return CreateMaybeMessage<ClientSafeBrowsingReportRequest_HTTPHeader>(nullptr); + } + + ClientSafeBrowsingReportRequest_HTTPHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientSafeBrowsingReportRequest_HTTPHeader* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const void* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + 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; + void set_value(const std::string& value); + void set_value(std::string&& value); + void set_value(const char* value); + void set_value(const void* value, size_t size); + std::string* mutable_value(); + std::string* release_value(); + void set_allocated_value(std::string* value); + private: + const std::string& _internal_value() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine) */ { + public: + ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(); + virtual ~ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* New() const final { + return CreateMaybeMessage<ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine>(nullptr); + } + + ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_verb(const std::string& value); + void set_verb(std::string&& value); + void set_verb(const char* value); + void set_verb(const void* value, size_t size); + std::string* mutable_verb(); + std::string* release_verb(); + void set_allocated_verb(std::string* verb); + private: + const std::string& _internal_verb() const; + 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; + void set_uri(const std::string& value); + void set_uri(std::string&& value); + void set_uri(const char* value); + void set_uri(const void* value, size_t size); + std::string* mutable_uri(); + std::string* release_uri(); + void set_allocated_uri(std::string* uri); + private: + const std::string& _internal_uri() const; + 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; + void set_version(const std::string& value); + void set_version(std::string&& value); + void set_version(const char* value); + void set_version(const void* value, size_t size); + std::string* mutable_version(); + std::string* release_version(); + void set_allocated_version(std::string* version); + private: + const std::string& _internal_version() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientSafeBrowsingReportRequest_HTTPRequest : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest) */ { + public: + ClientSafeBrowsingReportRequest_HTTPRequest(); + virtual ~ClientSafeBrowsingReportRequest_HTTPRequest(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientSafeBrowsingReportRequest_HTTPRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientSafeBrowsingReportRequest_HTTPRequest* New() const final { + return CreateMaybeMessage<ClientSafeBrowsingReportRequest_HTTPRequest>(nullptr); + } + + ClientSafeBrowsingReportRequest_HTTPRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientSafeBrowsingReportRequest_HTTPRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_body(const std::string& value); + void set_body(std::string&& value); + void set_body(const char* value); + void set_body(const void* value, size_t size); + std::string* mutable_body(); + std::string* release_body(); + void set_allocated_body(std::string* body); + private: + const std::string& _internal_body() const; + 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; + void set_bodydigest(const std::string& value); + void set_bodydigest(std::string&& value); + void set_bodydigest(const char* value); + void set_bodydigest(const void* value, size_t size); + std::string* mutable_bodydigest(); + std::string* release_bodydigest(); + void set_allocated_bodydigest(std::string* bodydigest); + private: + const std::string& _internal_bodydigest() const; + 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; + ::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: + + // optional int32 bodylength = 5; + bool has_bodylength() const; + private: + bool _internal_has_bodylength() const; + public: + void clear_bodylength(); + ::PROTOBUF_NAMESPACE_ID::int32 bodylength() const; + void set_bodylength(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_bodylength() const; + void _internal_set_bodylength(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int32 bodylength_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine) */ { + public: + ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(); + virtual ~ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* New() const final { + return CreateMaybeMessage<ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine>(nullptr); + } + + ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_message(const std::string& value); + void set_message(std::string&& value); + void set_message(const char* value); + void set_message(const void* value, size_t size); + std::string* mutable_message(); + std::string* release_message(); + void set_allocated_message(std::string* message); + private: + const std::string& _internal_message() const; + 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; + void set_version(const std::string& value); + void set_version(std::string&& value); + void set_version(const char* value); + void set_version(const void* value, size_t size); + std::string* mutable_version(); + std::string* release_version(); + void set_allocated_version(std::string* version); + private: + const std::string& _internal_version() const; + 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(); + ::PROTOBUF_NAMESPACE_ID::int32 code() const; + void set_code(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_code() const; + void _internal_set_code(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int32 code_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientSafeBrowsingReportRequest_HTTPResponse : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse) */ { + public: + ClientSafeBrowsingReportRequest_HTTPResponse(); + virtual ~ClientSafeBrowsingReportRequest_HTTPResponse(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientSafeBrowsingReportRequest_HTTPResponse& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientSafeBrowsingReportRequest_HTTPResponse* New() const final { + return CreateMaybeMessage<ClientSafeBrowsingReportRequest_HTTPResponse>(nullptr); + } + + ClientSafeBrowsingReportRequest_HTTPResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientSafeBrowsingReportRequest_HTTPResponse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_body(const std::string& value); + void set_body(std::string&& value); + void set_body(const char* value); + void set_body(const void* value, size_t size); + std::string* mutable_body(); + std::string* release_body(); + void set_allocated_body(std::string* body); + private: + const std::string& _internal_body() const; + 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; + void set_bodydigest(const std::string& value); + void set_bodydigest(std::string&& value); + void set_bodydigest(const char* value); + void set_bodydigest(const void* value, size_t size); + std::string* mutable_bodydigest(); + std::string* release_bodydigest(); + void set_allocated_bodydigest(std::string* bodydigest); + private: + const std::string& _internal_bodydigest() const; + 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; + void set_remote_ip(const std::string& value); + void set_remote_ip(std::string&& value); + void set_remote_ip(const char* value); + void set_remote_ip(const void* value, size_t size); + std::string* mutable_remote_ip(); + std::string* release_remote_ip(); + void set_allocated_remote_ip(std::string* remote_ip); + private: + const std::string& _internal_remote_ip() const; + 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; + ::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: + + // optional int32 bodylength = 5; + bool has_bodylength() const; + private: + bool _internal_has_bodylength() const; + public: + void clear_bodylength(); + ::PROTOBUF_NAMESPACE_ID::int32 bodylength() const; + void set_bodylength(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_bodylength() const; + void _internal_set_bodylength(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + ::PROTOBUF_NAMESPACE_ID::int32 bodylength_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientSafeBrowsingReportRequest_Resource : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.Resource) */ { + public: + ClientSafeBrowsingReportRequest_Resource(); + virtual ~ClientSafeBrowsingReportRequest_Resource(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientSafeBrowsingReportRequest_Resource& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientSafeBrowsingReportRequest_Resource* New() const final { + return CreateMaybeMessage<ClientSafeBrowsingReportRequest_Resource>(nullptr); + } + + ClientSafeBrowsingReportRequest_Resource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientSafeBrowsingReportRequest_Resource* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientSafeBrowsingReportRequest.Resource"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_child_ids(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + _internal_child_ids() const; + void _internal_add_child_ids(::PROTOBUF_NAMESPACE_ID::int32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + _internal_mutable_child_ids(); + public: + ::PROTOBUF_NAMESPACE_ID::int32 child_ids(int index) const; + void set_child_ids(int index, ::PROTOBUF_NAMESPACE_ID::int32 value); + void add_child_ids(::PROTOBUF_NAMESPACE_ID::int32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + child_ids() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + 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; + void set_url(const std::string& value); + void set_url(std::string&& value); + void set_url(const char* value); + void set_url(const char* value, size_t size); + std::string* mutable_url(); + std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + 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; + void set_tag_name(const std::string& value); + void set_tag_name(std::string&& value); + void set_tag_name(const char* value); + void set_tag_name(const char* value, size_t size); + std::string* mutable_tag_name(); + std::string* release_tag_name(); + void set_allocated_tag_name(std::string* tag_name); + private: + const std::string& _internal_tag_name() const; + 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; + ::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: + + // 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; + ::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: + + // required int32 id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + ::PROTOBUF_NAMESPACE_ID::int32 id() const; + void set_id(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_id() const; + void _internal_set_id(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // optional int32 parent_id = 5; + bool has_parent_id() const; + private: + bool _internal_has_parent_id() const; + public: + void clear_parent_id(); + ::PROTOBUF_NAMESPACE_ID::int32 parent_id() const; + void set_parent_id(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_parent_id() const; + void _internal_set_parent_id(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.Resource) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > 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_; + ::PROTOBUF_NAMESPACE_ID::int32 id_; + ::PROTOBUF_NAMESPACE_ID::int32 parent_id_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties) */ { + public: + ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(); + virtual ~ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* New() const final { + return CreateMaybeMessage<ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties>(nullptr); + } + + ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_client_version(const std::string& value); + void set_client_version(std::string&& value); + void set_client_version(const char* value); + void set_client_version(const char* value, size_t size); + std::string* mutable_client_version(); + std::string* release_client_version(); + void set_allocated_client_version(std::string* client_version); + private: + const std::string& _internal_client_version() const; + 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(); + ::PROTOBUF_NAMESPACE_ID::int64 google_play_services_version() const; + void set_google_play_services_version(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_google_play_services_version() const; + void _internal_set_google_play_services_version(::PROTOBUF_NAMESPACE_ID::int64 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_version_; + ::PROTOBUF_NAMESPACE_ID::int64 google_play_services_version_; + bool is_instant_apps_; + int url_api_type_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientSafeBrowsingReportRequest : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ClientSafeBrowsingReportRequest) */ { + public: + ClientSafeBrowsingReportRequest(); + virtual ~ClientSafeBrowsingReportRequest(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientSafeBrowsingReportRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ClientSafeBrowsingReportRequest* New() const final { + return CreateMaybeMessage<ClientSafeBrowsingReportRequest>(nullptr); + } + + ClientSafeBrowsingReportRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ClientSafeBrowsingReportRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ClientSafeBrowsingReportRequest"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(const std::string& 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(const std::string& 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; + void set_url(const std::string& value); + void set_url(std::string&& value); + void set_url(const char* value); + void set_url(const char* value, size_t size); + std::string* mutable_url(); + std::string* release_url(); + void set_allocated_url(std::string* url); + private: + const std::string& _internal_url() const; + 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; + void set_page_url(const std::string& value); + void set_page_url(std::string&& value); + void set_page_url(const char* value); + void set_page_url(const char* value, size_t size); + std::string* mutable_page_url(); + std::string* release_page_url(); + void set_allocated_page_url(std::string* page_url); + private: + const std::string& _internal_page_url() const; + 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; + void set_referrer_url(const std::string& value); + void set_referrer_url(std::string&& value); + void set_referrer_url(const char* value); + void set_referrer_url(const char* value, size_t size); + std::string* mutable_referrer_url(); + std::string* release_referrer_url(); + void set_allocated_referrer_url(std::string* referrer_url); + private: + const std::string& _internal_referrer_url() const; + 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; + void set_client_country(const std::string& value); + void set_client_country(std::string&& value); + void set_client_country(const char* value); + void set_client_country(const char* value, size_t size); + std::string* mutable_client_country(); + std::string* release_client_country(); + void set_allocated_client_country(std::string* client_country); + private: + const std::string& _internal_client_country() const; + 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; + void set_token(const std::string& value); + void set_token(std::string&& value); + void set_token(const char* value); + void set_token(const void* value, size_t size); + std::string* mutable_token(); + std::string* release_token(); + void set_allocated_token(std::string* token); + private: + const std::string& _internal_token() const; + 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; + ::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: + + // 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class HTMLElement_Attribute : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.HTMLElement.Attribute) */ { + public: + HTMLElement_Attribute(); + virtual ~HTMLElement_Attribute(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const HTMLElement_Attribute& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HTMLElement_Attribute* New() const final { + return CreateMaybeMessage<HTMLElement_Attribute>(nullptr); + } + + HTMLElement_Attribute* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(HTMLElement_Attribute* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.HTMLElement.Attribute"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + 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; + void set_value(const std::string& value); + void set_value(std::string&& value); + void set_value(const char* value); + void set_value(const char* value, size_t size); + std::string* mutable_value(); + std::string* release_value(); + void set_allocated_value(std::string* value); + private: + const std::string& _internal_value() const; + 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; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class HTMLElement : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.HTMLElement) */ { + public: + HTMLElement(); + virtual ~HTMLElement(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const HTMLElement& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HTMLElement* New() const final { + return CreateMaybeMessage<HTMLElement>(nullptr); + } + + HTMLElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(HTMLElement* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.HTMLElement"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_child_ids(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + _internal_child_ids() const; + void _internal_add_child_ids(::PROTOBUF_NAMESPACE_ID::int32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + _internal_mutable_child_ids(); + public: + ::PROTOBUF_NAMESPACE_ID::int32 child_ids(int index) const; + void set_child_ids(int index, ::PROTOBUF_NAMESPACE_ID::int32 value); + void add_child_ids(::PROTOBUF_NAMESPACE_ID::int32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + child_ids() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + 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; + void set_tag(const std::string& value); + void set_tag(std::string&& value); + void set_tag(const char* value); + void set_tag(const char* value, size_t size); + std::string* mutable_tag(); + std::string* release_tag(); + void set_allocated_tag(std::string* tag); + private: + const std::string& _internal_tag() const; + 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(); + ::PROTOBUF_NAMESPACE_ID::int32 id() const; + void set_id(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_id() const; + void _internal_set_id(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // optional int32 resource_id = 5; + bool has_resource_id() const; + private: + bool _internal_has_resource_id() const; + public: + void clear_resource_id(); + ::PROTOBUF_NAMESPACE_ID::int32 resource_id() const; + void set_resource_id(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_resource_id() const; + void _internal_set_resource_id(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.HTMLElement) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > child_ids_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::HTMLElement_Attribute > attribute_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tag_; + ::PROTOBUF_NAMESPACE_ID::int32 id_; + ::PROTOBUF_NAMESPACE_ID::int32 resource_id_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ImageData_Dimensions : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ImageData.Dimensions) */ { + public: + ImageData_Dimensions(); + virtual ~ImageData_Dimensions(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ImageData_Dimensions& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ImageData_Dimensions* New() const final { + return CreateMaybeMessage<ImageData_Dimensions>(nullptr); + } + + ImageData_Dimensions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ImageData_Dimensions* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ImageData.Dimensions"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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(); + ::PROTOBUF_NAMESPACE_ID::int32 width() const; + void set_width(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_width() const; + void _internal_set_width(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // optional int32 height = 2; + bool has_height() const; + private: + bool _internal_has_height() const; + public: + void clear_height(); + ::PROTOBUF_NAMESPACE_ID::int32 height() const; + void set_height(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_height() const; + void _internal_set_height(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:safe_browsing.ImageData.Dimensions) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::int32 width_; + ::PROTOBUF_NAMESPACE_ID::int32 height_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class ImageData : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.ImageData) */ { + public: + ImageData(); + virtual ~ImageData(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ImageData& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ImageData* New() const final { + return CreateMaybeMessage<ImageData>(nullptr); + } + + ImageData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ImageData* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.ImageData"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_data(const std::string& value); + void set_data(std::string&& value); + void set_data(const char* value); + void set_data(const void* value, size_t size); + std::string* mutable_data(); + std::string* release_data(); + void set_allocated_data(std::string* data); + private: + const std::string& _internal_data() const; + 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; + void set_mime_type(const std::string& value); + void set_mime_type(std::string&& value); + void set_mime_type(const char* value); + void set_mime_type(const char* value, size_t size); + std::string* mutable_mime_type(); + std::string* release_mime_type(); + void set_allocated_mime_type(std::string* mime_type); + private: + const std::string& _internal_mime_type() const; + 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; + ::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: + + // 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; + ::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: + + // @@protoc_insertion_point(class_scope:safe_browsing.ImageData) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + friend struct ::TableStruct_csd_2eproto; +}; +// ------------------------------------------------------------------- + +class NotificationImageReportRequest : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:safe_browsing.NotificationImageReportRequest) */ { + public: + NotificationImageReportRequest(); + virtual ~NotificationImageReportRequest(); + + 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 (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const NotificationImageReportRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + 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; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline NotificationImageReportRequest* New() const final { + return CreateMaybeMessage<NotificationImageReportRequest>(nullptr); + } + + NotificationImageReportRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + void DiscardUnknownFields(); + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(NotificationImageReportRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "safe_browsing.NotificationImageReportRequest"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + 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; + void set_notification_origin(const std::string& value); + void set_notification_origin(std::string&& value); + void set_notification_origin(const char* value); + void set_notification_origin(const char* value, size_t size); + std::string* mutable_notification_origin(); + std::string* release_notification_origin(); + void set_allocated_notification_origin(std::string* notification_origin); + private: + const std::string& _internal_notification_origin() const; + 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; + ::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: + + // @@protoc_insertion_point(class_scope:safe_browsing.NotificationImageReportRequest) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_; + ::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_; + 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 = (_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() { + user_population_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::safe_browsing::ChromeUserPopulation_UserPopulation ChromeUserPopulation::_internal_user_population() const { + return static_cast< ::safe_browsing::ChromeUserPopulation_UserPopulation >(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)); + _has_bits_[0] |= 0x00000001u; + 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 = (_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() { + is_history_sync_enabled_ = false; + _has_bits_[0] &= ~0x00000002u; +} +inline bool ChromeUserPopulation::_internal_is_history_sync_enabled() const { + return 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) { + _has_bits_[0] |= 0x00000002u; + 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 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() { + finch_active_groups_.Clear(); +} +inline std::string* ChromeUserPopulation::add_finch_active_groups() { + // @@protoc_insertion_point(field_add_mutable:safe_browsing.ChromeUserPopulation.finch_active_groups) + return _internal_add_finch_active_groups(); +} +inline const std::string& ChromeUserPopulation::_internal_finch_active_groups(int index) const { + return 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 finch_active_groups_.Mutable(index); +} +inline void ChromeUserPopulation::set_finch_active_groups(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ChromeUserPopulation.finch_active_groups) + finch_active_groups_.Mutable(index)->assign(value); +} +inline void ChromeUserPopulation::set_finch_active_groups(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ChromeUserPopulation.finch_active_groups) + finch_active_groups_.Mutable(index)->assign(std::move(value)); +} +inline void ChromeUserPopulation::set_finch_active_groups(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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) { + 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 finch_active_groups_.Add(); +} +inline void ChromeUserPopulation::add_finch_active_groups(const std::string& value) { + 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) { + 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); + 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) { + 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 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 &finch_active_groups_; +} + +// ------------------------------------------------------------------- + +// ClientPhishingRequest_Feature + +// required string name = 1; +inline bool ClientPhishingRequest_Feature::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientPhishingRequest_Feature::has_name() const { + return _internal_has_name(); +} +inline void ClientPhishingRequest_Feature::clear_name() { + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientPhishingRequest_Feature::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.Feature.name) +} +inline std::string* ClientPhishingRequest_Feature::mutable_name() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.Feature.name) + return _internal_mutable_name(); +} +inline const std::string& ClientPhishingRequest_Feature::_internal_name() const { + return name_.GetNoArena(); +} +inline void ClientPhishingRequest_Feature::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientPhishingRequest_Feature::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientPhishingRequest.Feature.name) +} +inline void ClientPhishingRequest_Feature::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientPhishingRequest.Feature.name) +} +inline void ClientPhishingRequest_Feature::set_name(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientPhishingRequest.Feature.name) +} +inline std::string* ClientPhishingRequest_Feature::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientPhishingRequest_Feature::release_name() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientPhishingRequest.Feature.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientPhishingRequest_Feature::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientPhishingRequest_Feature::has_value() const { + return _internal_has_value(); +} +inline void ClientPhishingRequest_Feature::clear_value() { + value_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline double ClientPhishingRequest_Feature::_internal_value() const { + return 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) { + _has_bits_[0] |= 0x00000002u; + 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientPhishingRequest::has_url() const { + return _internal_has_url(); +} +inline void ClientPhishingRequest::clear_url() { + url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientPhishingRequest::url() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.url) + return _internal_url(); +} +inline void ClientPhishingRequest::set_url(const std::string& value) { + _internal_set_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.url) +} +inline std::string* ClientPhishingRequest::mutable_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.url) + return _internal_mutable_url(); +} +inline const std::string& ClientPhishingRequest::_internal_url() const { + return url_.GetNoArena(); +} +inline void ClientPhishingRequest::_internal_set_url(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientPhishingRequest::set_url(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientPhishingRequest.url) +} +inline void ClientPhishingRequest::set_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientPhishingRequest.url) +} +inline void ClientPhishingRequest::set_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientPhishingRequest.url) +} +inline std::string* ClientPhishingRequest::_internal_mutable_url() { + _has_bits_[0] |= 0x00000001u; + return url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientPhishingRequest::release_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientPhishingRequest.url) + if (!_internal_has_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientPhishingRequest::set_allocated_url(std::string* url) { + if (url != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url); + // @@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 = (_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() { + obsolete_hash_prefix_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientPhishingRequest::set_obsolete_hash_prefix(const std::string& value) { + _internal_set_obsolete_hash_prefix(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix) +} +inline std::string* ClientPhishingRequest::mutable_obsolete_hash_prefix() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix) + return _internal_mutable_obsolete_hash_prefix(); +} +inline const std::string& ClientPhishingRequest::_internal_obsolete_hash_prefix() const { + return obsolete_hash_prefix_.GetNoArena(); +} +inline void ClientPhishingRequest::_internal_set_obsolete_hash_prefix(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + obsolete_hash_prefix_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientPhishingRequest::set_obsolete_hash_prefix(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + obsolete_hash_prefix_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix) +} +inline void ClientPhishingRequest::set_obsolete_hash_prefix(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + obsolete_hash_prefix_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix) +} +inline void ClientPhishingRequest::set_obsolete_hash_prefix(const void* value, size_t size) { + _has_bits_[0] |= 0x00000004u; + obsolete_hash_prefix_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix) +} +inline std::string* ClientPhishingRequest::_internal_mutable_obsolete_hash_prefix() { + _has_bits_[0] |= 0x00000004u; + return obsolete_hash_prefix_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000004u; + return obsolete_hash_prefix_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientPhishingRequest::set_allocated_obsolete_hash_prefix(std::string* obsolete_hash_prefix) { + if (obsolete_hash_prefix != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + obsolete_hash_prefix_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), obsolete_hash_prefix); + // @@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 = (_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() { + client_score_ = 0; + _has_bits_[0] &= ~0x00000020u; +} +inline float ClientPhishingRequest::_internal_client_score() const { + return 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) { + _has_bits_[0] |= 0x00000020u; + 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 = (_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() { + is_phishing_ = false; + _has_bits_[0] &= ~0x00000040u; +} +inline bool ClientPhishingRequest::_internal_is_phishing() const { + return 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) { + _has_bits_[0] |= 0x00000040u; + 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 feature_map_.size(); +} +inline int ClientPhishingRequest::feature_map_size() const { + return _internal_feature_map_size(); +} +inline void ClientPhishingRequest::clear_feature_map() { + 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 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 &feature_map_; +} +inline const ::safe_browsing::ClientPhishingRequest_Feature& ClientPhishingRequest::_internal_feature_map(int index) const { + return 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 feature_map_.Add(); +} +inline ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::add_feature_map() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientPhishingRequest.feature_map) + return _internal_add_feature_map(); +} +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 feature_map_; +} + +// optional int32 model_version = 6; +inline bool ClientPhishingRequest::_internal_has_model_version() const { + bool value = (_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() { + model_version_ = 0; + _has_bits_[0] &= ~0x00000080u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientPhishingRequest::_internal_model_version() const { + return model_version_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000080u; + model_version_ = value; +} +inline void ClientPhishingRequest::set_model_version(::PROTOBUF_NAMESPACE_ID::int32 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 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() { + 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 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 &non_model_feature_map_; +} +inline const ::safe_browsing::ClientPhishingRequest_Feature& ClientPhishingRequest::_internal_non_model_feature_map(int index) const { + return 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 non_model_feature_map_.Add(); +} +inline ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::add_non_model_feature_map() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientPhishingRequest.non_model_feature_map) + return _internal_add_non_model_feature_map(); +} +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 non_model_feature_map_; +} + +// optional string OBSOLETE_referrer_url = 9; +inline bool ClientPhishingRequest::_internal_has_obsolete_referrer_url() const { + bool value = (_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() { + obsolete_referrer_url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientPhishingRequest::set_obsolete_referrer_url(const std::string& value) { + _internal_set_obsolete_referrer_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url) +} +inline std::string* ClientPhishingRequest::mutable_obsolete_referrer_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url) + return _internal_mutable_obsolete_referrer_url(); +} +inline const std::string& ClientPhishingRequest::_internal_obsolete_referrer_url() const { + return obsolete_referrer_url_.GetNoArena(); +} +inline void ClientPhishingRequest::_internal_set_obsolete_referrer_url(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + obsolete_referrer_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientPhishingRequest::set_obsolete_referrer_url(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + obsolete_referrer_url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url) +} +inline void ClientPhishingRequest::set_obsolete_referrer_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + obsolete_referrer_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url) +} +inline void ClientPhishingRequest::set_obsolete_referrer_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + obsolete_referrer_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url) +} +inline std::string* ClientPhishingRequest::_internal_mutable_obsolete_referrer_url() { + _has_bits_[0] |= 0x00000002u; + return obsolete_referrer_url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return obsolete_referrer_url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientPhishingRequest::set_allocated_obsolete_referrer_url(std::string* obsolete_referrer_url) { + if (obsolete_referrer_url != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + obsolete_referrer_url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), obsolete_referrer_url); + // @@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 shingle_hashes_.size(); +} +inline int ClientPhishingRequest::shingle_hashes_size() const { + return _internal_shingle_hashes_size(); +} +inline void ClientPhishingRequest::clear_shingle_hashes() { + shingle_hashes_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientPhishingRequest::_internal_shingle_hashes(int index) const { + return shingle_hashes_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 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, ::PROTOBUF_NAMESPACE_ID::uint32 value) { + shingle_hashes_.Set(index, value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.shingle_hashes) +} +inline void ClientPhishingRequest::_internal_add_shingle_hashes(::PROTOBUF_NAMESPACE_ID::uint32 value) { + shingle_hashes_.Add(value); +} +inline void ClientPhishingRequest::add_shingle_hashes(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_add_shingle_hashes(value); + // @@protoc_insertion_point(field_add:safe_browsing.ClientPhishingRequest.shingle_hashes) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ClientPhishingRequest::_internal_shingle_hashes() const { + return shingle_hashes_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >& +ClientPhishingRequest::shingle_hashes() const { + // @@protoc_insertion_point(field_list:safe_browsing.ClientPhishingRequest.shingle_hashes) + return _internal_shingle_hashes(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +ClientPhishingRequest::_internal_mutable_shingle_hashes() { + return &shingle_hashes_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >* +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 = (_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() { + model_filename_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientPhishingRequest::set_model_filename(const std::string& value) { + _internal_set_model_filename(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.model_filename) +} +inline std::string* ClientPhishingRequest::mutable_model_filename() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.model_filename) + return _internal_mutable_model_filename(); +} +inline const std::string& ClientPhishingRequest::_internal_model_filename() const { + return model_filename_.GetNoArena(); +} +inline void ClientPhishingRequest::_internal_set_model_filename(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + model_filename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientPhishingRequest::set_model_filename(std::string&& value) { + _has_bits_[0] |= 0x00000008u; + model_filename_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientPhishingRequest.model_filename) +} +inline void ClientPhishingRequest::set_model_filename(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000008u; + model_filename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientPhishingRequest.model_filename) +} +inline void ClientPhishingRequest::set_model_filename(const char* value, size_t size) { + _has_bits_[0] |= 0x00000008u; + model_filename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientPhishingRequest.model_filename) +} +inline std::string* ClientPhishingRequest::_internal_mutable_model_filename() { + _has_bits_[0] |= 0x00000008u; + return model_filename_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientPhishingRequest::release_model_filename() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientPhishingRequest.model_filename) + if (!_internal_has_model_filename()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + return model_filename_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientPhishingRequest::set_allocated_model_filename(std::string* model_filename) { + if (model_filename != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + model_filename_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), model_filename); + // @@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 = (_has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || population_ != nullptr); + return value; +} +inline bool ClientPhishingRequest::has_population() const { + return _internal_has_population(); +} +inline void ClientPhishingRequest::clear_population() { + if (population_ != nullptr) population_->Clear(); + _has_bits_[0] &= ~0x00000010u; +} +inline const ::safe_browsing::ChromeUserPopulation& ClientPhishingRequest::_internal_population() const { + const ::safe_browsing::ChromeUserPopulation* p = 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 ::safe_browsing::ChromeUserPopulation* ClientPhishingRequest::release_population() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientPhishingRequest.population) + _has_bits_[0] &= ~0x00000010u; + ::safe_browsing::ChromeUserPopulation* temp = population_; + population_ = nullptr; + return temp; +} +inline ::safe_browsing::ChromeUserPopulation* ClientPhishingRequest::_internal_mutable_population() { + _has_bits_[0] |= 0x00000010u; + if (population_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ChromeUserPopulation>(GetArenaNoVirtual()); + population_ = p; + } + return population_; +} +inline ::safe_browsing::ChromeUserPopulation* ClientPhishingRequest::mutable_population() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.population) + return _internal_mutable_population(); +} +inline void ClientPhishingRequest::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete population_; + } + if (population) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + population = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, population, submessage_arena); + } + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientPhishingResponse::has_phishy() const { + return _internal_has_phishy(); +} +inline void ClientPhishingResponse::clear_phishy() { + phishy_ = false; + _has_bits_[0] &= ~0x00000001u; +} +inline bool ClientPhishingResponse::_internal_phishy() const { + return 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) { + _has_bits_[0] |= 0x00000001u; + 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 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() { + obsolete_whitelist_expression_.Clear(); +} +inline std::string* ClientPhishingResponse::add_obsolete_whitelist_expression() { + // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression) + return _internal_add_obsolete_whitelist_expression(); +} +inline const std::string& ClientPhishingResponse::_internal_obsolete_whitelist_expression(int index) const { + return 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 obsolete_whitelist_expression_.Mutable(index); +} +inline void ClientPhishingResponse::set_obsolete_whitelist_expression(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression) + obsolete_whitelist_expression_.Mutable(index)->assign(value); +} +inline void ClientPhishingResponse::set_obsolete_whitelist_expression(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression) + obsolete_whitelist_expression_.Mutable(index)->assign(std::move(value)); +} +inline void ClientPhishingResponse::set_obsolete_whitelist_expression(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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) { + 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 obsolete_whitelist_expression_.Add(); +} +inline void ClientPhishingResponse::add_obsolete_whitelist_expression(const std::string& value) { + 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) { + 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); + 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) { + 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 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 &obsolete_whitelist_expression_; +} + +// ------------------------------------------------------------------- + +// ClientMalwareRequest_UrlInfo + +// required string ip = 1; +inline bool ClientMalwareRequest_UrlInfo::_internal_has_ip() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientMalwareRequest_UrlInfo::has_ip() const { + return _internal_has_ip(); +} +inline void ClientMalwareRequest_UrlInfo::clear_ip() { + ip_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientMalwareRequest_UrlInfo::set_ip(const std::string& value) { + _internal_set_ip(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.ip) +} +inline std::string* ClientMalwareRequest_UrlInfo::mutable_ip() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.UrlInfo.ip) + return _internal_mutable_ip(); +} +inline const std::string& ClientMalwareRequest_UrlInfo::_internal_ip() const { + return ip_.GetNoArena(); +} +inline void ClientMalwareRequest_UrlInfo::_internal_set_ip(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientMalwareRequest_UrlInfo::set_ip(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + ip_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientMalwareRequest.UrlInfo.ip) +} +inline void ClientMalwareRequest_UrlInfo::set_ip(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareRequest.UrlInfo.ip) +} +inline void ClientMalwareRequest_UrlInfo::set_ip(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareRequest.UrlInfo.ip) +} +inline std::string* ClientMalwareRequest_UrlInfo::_internal_mutable_ip() { + _has_bits_[0] |= 0x00000001u; + return ip_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientMalwareRequest_UrlInfo::release_ip() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.UrlInfo.ip) + if (!_internal_has_ip()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return ip_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientMalwareRequest_UrlInfo::set_allocated_ip(std::string* ip) { + if (ip != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + ip_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ip); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientMalwareRequest_UrlInfo::has_url() const { + return _internal_has_url(); +} +inline void ClientMalwareRequest_UrlInfo::clear_url() { + url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientMalwareRequest_UrlInfo::set_url(const std::string& value) { + _internal_set_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.url) +} +inline std::string* ClientMalwareRequest_UrlInfo::mutable_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.UrlInfo.url) + return _internal_mutable_url(); +} +inline const std::string& ClientMalwareRequest_UrlInfo::_internal_url() const { + return url_.GetNoArena(); +} +inline void ClientMalwareRequest_UrlInfo::_internal_set_url(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientMalwareRequest_UrlInfo::set_url(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientMalwareRequest.UrlInfo.url) +} +inline void ClientMalwareRequest_UrlInfo::set_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareRequest.UrlInfo.url) +} +inline void ClientMalwareRequest_UrlInfo::set_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareRequest.UrlInfo.url) +} +inline std::string* ClientMalwareRequest_UrlInfo::_internal_mutable_url() { + _has_bits_[0] |= 0x00000002u; + return url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientMalwareRequest_UrlInfo::release_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.UrlInfo.url) + if (!_internal_has_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientMalwareRequest_UrlInfo::set_allocated_url(std::string* url) { + if (url != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url); + // @@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 = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ClientMalwareRequest_UrlInfo::has_method() const { + return _internal_has_method(); +} +inline void ClientMalwareRequest_UrlInfo::clear_method() { + method_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientMalwareRequest_UrlInfo::set_method(const std::string& value) { + _internal_set_method(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.method) +} +inline std::string* ClientMalwareRequest_UrlInfo::mutable_method() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.UrlInfo.method) + return _internal_mutable_method(); +} +inline const std::string& ClientMalwareRequest_UrlInfo::_internal_method() const { + return method_.GetNoArena(); +} +inline void ClientMalwareRequest_UrlInfo::_internal_set_method(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + method_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientMalwareRequest_UrlInfo::set_method(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + method_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientMalwareRequest.UrlInfo.method) +} +inline void ClientMalwareRequest_UrlInfo::set_method(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + method_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareRequest.UrlInfo.method) +} +inline void ClientMalwareRequest_UrlInfo::set_method(const char* value, size_t size) { + _has_bits_[0] |= 0x00000004u; + method_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareRequest.UrlInfo.method) +} +inline std::string* ClientMalwareRequest_UrlInfo::_internal_mutable_method() { + _has_bits_[0] |= 0x00000004u; + return method_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientMalwareRequest_UrlInfo::release_method() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.UrlInfo.method) + if (!_internal_has_method()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + return method_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientMalwareRequest_UrlInfo::set_allocated_method(std::string* method) { + if (method != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + method_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), method); + // @@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 = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ClientMalwareRequest_UrlInfo::has_referrer() const { + return _internal_has_referrer(); +} +inline void ClientMalwareRequest_UrlInfo::clear_referrer() { + referrer_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientMalwareRequest_UrlInfo::set_referrer(const std::string& value) { + _internal_set_referrer(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.referrer) +} +inline std::string* ClientMalwareRequest_UrlInfo::mutable_referrer() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.UrlInfo.referrer) + return _internal_mutable_referrer(); +} +inline const std::string& ClientMalwareRequest_UrlInfo::_internal_referrer() const { + return referrer_.GetNoArena(); +} +inline void ClientMalwareRequest_UrlInfo::_internal_set_referrer(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + referrer_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientMalwareRequest_UrlInfo::set_referrer(std::string&& value) { + _has_bits_[0] |= 0x00000008u; + referrer_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientMalwareRequest.UrlInfo.referrer) +} +inline void ClientMalwareRequest_UrlInfo::set_referrer(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000008u; + referrer_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareRequest.UrlInfo.referrer) +} +inline void ClientMalwareRequest_UrlInfo::set_referrer(const char* value, size_t size) { + _has_bits_[0] |= 0x00000008u; + referrer_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareRequest.UrlInfo.referrer) +} +inline std::string* ClientMalwareRequest_UrlInfo::_internal_mutable_referrer() { + _has_bits_[0] |= 0x00000008u; + return referrer_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientMalwareRequest_UrlInfo::release_referrer() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.UrlInfo.referrer) + if (!_internal_has_referrer()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + return referrer_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientMalwareRequest_UrlInfo::set_allocated_referrer(std::string* referrer) { + if (referrer != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + referrer_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), referrer); + // @@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 = (_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() { + resource_type_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientMalwareRequest_UrlInfo::_internal_resource_type() const { + return resource_type_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000010u; + resource_type_ = value; +} +inline void ClientMalwareRequest_UrlInfo::set_resource_type(::PROTOBUF_NAMESPACE_ID::int32 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientMalwareRequest::has_url() const { + return _internal_has_url(); +} +inline void ClientMalwareRequest::clear_url() { + url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientMalwareRequest::url() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.url) + return _internal_url(); +} +inline void ClientMalwareRequest::set_url(const std::string& value) { + _internal_set_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.url) +} +inline std::string* ClientMalwareRequest::mutable_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.url) + return _internal_mutable_url(); +} +inline const std::string& ClientMalwareRequest::_internal_url() const { + return url_.GetNoArena(); +} +inline void ClientMalwareRequest::_internal_set_url(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientMalwareRequest::set_url(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientMalwareRequest.url) +} +inline void ClientMalwareRequest::set_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareRequest.url) +} +inline void ClientMalwareRequest::set_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareRequest.url) +} +inline std::string* ClientMalwareRequest::_internal_mutable_url() { + _has_bits_[0] |= 0x00000001u; + return url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientMalwareRequest::release_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.url) + if (!_internal_has_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientMalwareRequest::set_allocated_url(std::string* url) { + if (url != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url); + // @@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 = (_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() { + referrer_url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientMalwareRequest::set_referrer_url(const std::string& value) { + _internal_set_referrer_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.referrer_url) +} +inline std::string* ClientMalwareRequest::mutable_referrer_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.referrer_url) + return _internal_mutable_referrer_url(); +} +inline const std::string& ClientMalwareRequest::_internal_referrer_url() const { + return referrer_url_.GetNoArena(); +} +inline void ClientMalwareRequest::_internal_set_referrer_url(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + referrer_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientMalwareRequest::set_referrer_url(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + referrer_url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientMalwareRequest.referrer_url) +} +inline void ClientMalwareRequest::set_referrer_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + referrer_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareRequest.referrer_url) +} +inline void ClientMalwareRequest::set_referrer_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + referrer_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareRequest.referrer_url) +} +inline std::string* ClientMalwareRequest::_internal_mutable_referrer_url() { + _has_bits_[0] |= 0x00000002u; + return referrer_url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientMalwareRequest::release_referrer_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.referrer_url) + if (!_internal_has_referrer_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return referrer_url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientMalwareRequest::set_allocated_referrer_url(std::string* referrer_url) { + if (referrer_url != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + referrer_url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), referrer_url); + // @@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 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() { + 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 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 &bad_ip_url_info_; +} +inline const ::safe_browsing::ClientMalwareRequest_UrlInfo& ClientMalwareRequest::_internal_bad_ip_url_info(int index) const { + return 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 bad_ip_url_info_.Add(); +} +inline ::safe_browsing::ClientMalwareRequest_UrlInfo* ClientMalwareRequest::add_bad_ip_url_info() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientMalwareRequest.bad_ip_url_info) + return _internal_add_bad_ip_url_info(); +} +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 bad_ip_url_info_; +} + +// optional .safe_browsing.ChromeUserPopulation population = 9; +inline bool ClientMalwareRequest::_internal_has_population() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || population_ != nullptr); + return value; +} +inline bool ClientMalwareRequest::has_population() const { + return _internal_has_population(); +} +inline void ClientMalwareRequest::clear_population() { + if (population_ != nullptr) population_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::safe_browsing::ChromeUserPopulation& ClientMalwareRequest::_internal_population() const { + const ::safe_browsing::ChromeUserPopulation* p = 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 ::safe_browsing::ChromeUserPopulation* ClientMalwareRequest::release_population() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareRequest.population) + _has_bits_[0] &= ~0x00000004u; + ::safe_browsing::ChromeUserPopulation* temp = population_; + population_ = nullptr; + return temp; +} +inline ::safe_browsing::ChromeUserPopulation* ClientMalwareRequest::_internal_mutable_population() { + _has_bits_[0] |= 0x00000004u; + if (population_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ChromeUserPopulation>(GetArenaNoVirtual()); + population_ = p; + } + return population_; +} +inline ::safe_browsing::ChromeUserPopulation* ClientMalwareRequest::mutable_population() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.population) + return _internal_mutable_population(); +} +inline void ClientMalwareRequest::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete population_; + } + if (population) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + population = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, population, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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 = (_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() { + action_url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void LoginReputationClientRequest_Frame_Form::set_action_url(const std::string& value) { + _internal_set_action_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.Frame.Form.action_url) +} +inline std::string* LoginReputationClientRequest_Frame_Form::mutable_action_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.Frame.Form.action_url) + return _internal_mutable_action_url(); +} +inline const std::string& LoginReputationClientRequest_Frame_Form::_internal_action_url() const { + return action_url_.GetNoArena(); +} +inline void LoginReputationClientRequest_Frame_Form::_internal_set_action_url(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + action_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void LoginReputationClientRequest_Frame_Form::set_action_url(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + action_url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.LoginReputationClientRequest.Frame.Form.action_url) +} +inline void LoginReputationClientRequest_Frame_Form::set_action_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + action_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.LoginReputationClientRequest.Frame.Form.action_url) +} +inline void LoginReputationClientRequest_Frame_Form::set_action_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + action_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.LoginReputationClientRequest.Frame.Form.action_url) +} +inline std::string* LoginReputationClientRequest_Frame_Form::_internal_mutable_action_url() { + _has_bits_[0] |= 0x00000001u; + return action_url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return action_url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void LoginReputationClientRequest_Frame_Form::set_allocated_action_url(std::string* action_url) { + if (action_url != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + action_url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), action_url); + // @@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 = (_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() { + has_password_field_ = false; + _has_bits_[0] &= ~0x00000002u; +} +inline bool LoginReputationClientRequest_Frame_Form::_internal_has_password_field() const { + return 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) { + _has_bits_[0] |= 0x00000002u; + 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 = (_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() { + frame_index_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 LoginReputationClientRequest_Frame::_internal_frame_index() const { + return frame_index_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000002u; + frame_index_ = value; +} +inline void LoginReputationClientRequest_Frame::set_frame_index(::PROTOBUF_NAMESPACE_ID::int32 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 = (_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() { + parent_frame_index_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 LoginReputationClientRequest_Frame::_internal_parent_frame_index() const { + return parent_frame_index_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000004u; + parent_frame_index_ = value; +} +inline void LoginReputationClientRequest_Frame::set_parent_frame_index(::PROTOBUF_NAMESPACE_ID::int32 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool LoginReputationClientRequest_Frame::has_url() const { + return _internal_has_url(); +} +inline void LoginReputationClientRequest_Frame::clear_url() { + url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void LoginReputationClientRequest_Frame::set_url(const std::string& value) { + _internal_set_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.Frame.url) +} +inline std::string* LoginReputationClientRequest_Frame::mutable_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.Frame.url) + return _internal_mutable_url(); +} +inline const std::string& LoginReputationClientRequest_Frame::_internal_url() const { + return url_.GetNoArena(); +} +inline void LoginReputationClientRequest_Frame::_internal_set_url(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void LoginReputationClientRequest_Frame::set_url(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.LoginReputationClientRequest.Frame.url) +} +inline void LoginReputationClientRequest_Frame::set_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.LoginReputationClientRequest.Frame.url) +} +inline void LoginReputationClientRequest_Frame::set_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.LoginReputationClientRequest.Frame.url) +} +inline std::string* LoginReputationClientRequest_Frame::_internal_mutable_url() { + _has_bits_[0] |= 0x00000001u; + return url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* LoginReputationClientRequest_Frame::release_url() { + // @@protoc_insertion_point(field_release:safe_browsing.LoginReputationClientRequest.Frame.url) + if (!_internal_has_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void LoginReputationClientRequest_Frame::set_allocated_url(std::string* url) { + if (url != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url); + // @@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 = (_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() { + has_password_field_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool LoginReputationClientRequest_Frame::_internal_has_password_field() const { + return 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) { + _has_bits_[0] |= 0x00000008u; + 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 referrer_chain_.size(); +} +inline int LoginReputationClientRequest_Frame::referrer_chain_size() const { + return _internal_referrer_chain_size(); +} +inline void LoginReputationClientRequest_Frame::clear_referrer_chain() { + 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 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 &referrer_chain_; +} +inline const ::safe_browsing::ReferrerChainEntry& LoginReputationClientRequest_Frame::_internal_referrer_chain(int index) const { + return 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 referrer_chain_.Add(); +} +inline ::safe_browsing::ReferrerChainEntry* LoginReputationClientRequest_Frame::add_referrer_chain() { + // @@protoc_insertion_point(field_add:safe_browsing.LoginReputationClientRequest.Frame.referrer_chain) + return _internal_add_referrer_chain(); +} +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 referrer_chain_; +} + +// repeated .safe_browsing.LoginReputationClientRequest.Frame.Form forms = 6; +inline int LoginReputationClientRequest_Frame::_internal_forms_size() const { + return forms_.size(); +} +inline int LoginReputationClientRequest_Frame::forms_size() const { + return _internal_forms_size(); +} +inline void LoginReputationClientRequest_Frame::clear_forms() { + 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 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 &forms_; +} +inline const ::safe_browsing::LoginReputationClientRequest_Frame_Form& LoginReputationClientRequest_Frame::_internal_forms(int index) const { + return 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 forms_.Add(); +} +inline ::safe_browsing::LoginReputationClientRequest_Frame_Form* LoginReputationClientRequest_Frame::add_forms() { + // @@protoc_insertion_point(field_add:safe_browsing.LoginReputationClientRequest.Frame.forms) + return _internal_add_forms(); +} +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 forms_; +} + +// ------------------------------------------------------------------- + +// LoginReputationClientRequest_PasswordReuseEvent + +// repeated string domains_matching_password = 1; +inline int LoginReputationClientRequest_PasswordReuseEvent::_internal_domains_matching_password_size() const { + return 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() { + domains_matching_password_.Clear(); +} +inline std::string* LoginReputationClientRequest_PasswordReuseEvent::add_domains_matching_password() { + // @@protoc_insertion_point(field_add_mutable:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password) + return _internal_add_domains_matching_password(); +} +inline const std::string& LoginReputationClientRequest_PasswordReuseEvent::_internal_domains_matching_password(int index) const { + return 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 domains_matching_password_.Mutable(index); +} +inline void LoginReputationClientRequest_PasswordReuseEvent::set_domains_matching_password(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password) + domains_matching_password_.Mutable(index)->assign(value); +} +inline void LoginReputationClientRequest_PasswordReuseEvent::set_domains_matching_password(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.PasswordReuseEvent.domains_matching_password) + domains_matching_password_.Mutable(index)->assign(std::move(value)); +} +inline void LoginReputationClientRequest_PasswordReuseEvent::set_domains_matching_password(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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) { + 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 domains_matching_password_.Add(); +} +inline void LoginReputationClientRequest_PasswordReuseEvent::add_domains_matching_password(const std::string& value) { + 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) { + 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); + 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) { + 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 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 &domains_matching_password_; +} + +// optional int32 frame_id = 2; +inline bool LoginReputationClientRequest_PasswordReuseEvent::_internal_has_frame_id() const { + bool value = (_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() { + frame_id_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 LoginReputationClientRequest_PasswordReuseEvent::_internal_frame_id() const { + return frame_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000001u; + frame_id_ = value; +} +inline void LoginReputationClientRequest_PasswordReuseEvent::set_frame_id(::PROTOBUF_NAMESPACE_ID::int32 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 = (_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() { + is_chrome_signin_password_ = false; + _has_bits_[0] &= ~0x00000002u; +} +inline bool LoginReputationClientRequest_PasswordReuseEvent::_internal_is_chrome_signin_password() const { + return 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) { + _has_bits_[0] |= 0x00000002u; + 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 = (_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() { + sync_account_type_ = 0; + _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 >(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)); + _has_bits_[0] |= 0x00000004u; + 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 = (_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() { + page_url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void LoginReputationClientRequest::set_page_url(const std::string& value) { + _internal_set_page_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientRequest.page_url) +} +inline std::string* LoginReputationClientRequest::mutable_page_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.page_url) + return _internal_mutable_page_url(); +} +inline const std::string& LoginReputationClientRequest::_internal_page_url() const { + return page_url_.GetNoArena(); +} +inline void LoginReputationClientRequest::_internal_set_page_url(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + page_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void LoginReputationClientRequest::set_page_url(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + page_url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.LoginReputationClientRequest.page_url) +} +inline void LoginReputationClientRequest::set_page_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + page_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.LoginReputationClientRequest.page_url) +} +inline void LoginReputationClientRequest::set_page_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + page_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.LoginReputationClientRequest.page_url) +} +inline std::string* LoginReputationClientRequest::_internal_mutable_page_url() { + _has_bits_[0] |= 0x00000001u; + return page_url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* LoginReputationClientRequest::release_page_url() { + // @@protoc_insertion_point(field_release:safe_browsing.LoginReputationClientRequest.page_url) + if (!_internal_has_page_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return page_url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void LoginReputationClientRequest::set_allocated_page_url(std::string* page_url) { + if (page_url != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + page_url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), page_url); + // @@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 = (_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() { + trigger_type_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline ::safe_browsing::LoginReputationClientRequest_TriggerType LoginReputationClientRequest::_internal_trigger_type() const { + return static_cast< ::safe_browsing::LoginReputationClientRequest_TriggerType >(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)); + _has_bits_[0] |= 0x00000008u; + 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 frames_.size(); +} +inline int LoginReputationClientRequest::frames_size() const { + return _internal_frames_size(); +} +inline void LoginReputationClientRequest::clear_frames() { + frames_.Clear(); +} +inline ::safe_browsing::LoginReputationClientRequest_Frame* LoginReputationClientRequest::mutable_frames(int index) { + // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.frames) + return 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 &frames_; +} +inline const ::safe_browsing::LoginReputationClientRequest_Frame& LoginReputationClientRequest::_internal_frames(int index) const { + return 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 frames_.Add(); +} +inline ::safe_browsing::LoginReputationClientRequest_Frame* LoginReputationClientRequest::add_frames() { + // @@protoc_insertion_point(field_add:safe_browsing.LoginReputationClientRequest.frames) + return _internal_add_frames(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::LoginReputationClientRequest_Frame >& +LoginReputationClientRequest::frames() const { + // @@protoc_insertion_point(field_list:safe_browsing.LoginReputationClientRequest.frames) + return frames_; +} + +// optional .safe_browsing.LoginReputationClientRequest.PasswordReuseEvent password_reuse_event = 4; +inline bool LoginReputationClientRequest::_internal_has_password_reuse_event() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || 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 (password_reuse_event_ != nullptr) password_reuse_event_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent& LoginReputationClientRequest::_internal_password_reuse_event() const { + const ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* p = 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 ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* LoginReputationClientRequest::release_password_reuse_event() { + // @@protoc_insertion_point(field_release:safe_browsing.LoginReputationClientRequest.password_reuse_event) + _has_bits_[0] &= ~0x00000002u; + ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* temp = password_reuse_event_; + password_reuse_event_ = nullptr; + return temp; +} +inline ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* LoginReputationClientRequest::_internal_mutable_password_reuse_event() { + _has_bits_[0] |= 0x00000002u; + if (password_reuse_event_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent>(GetArenaNoVirtual()); + password_reuse_event_ = p; + } + return password_reuse_event_; +} +inline ::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* LoginReputationClientRequest::mutable_password_reuse_event() { + // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.password_reuse_event) + return _internal_mutable_password_reuse_event(); +} +inline void LoginReputationClientRequest::set_allocated_password_reuse_event(::safe_browsing::LoginReputationClientRequest_PasswordReuseEvent* password_reuse_event) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete password_reuse_event_; + } + if (password_reuse_event) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + password_reuse_event = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, password_reuse_event, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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 = (_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() { + stored_verdict_cnt_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 LoginReputationClientRequest::_internal_stored_verdict_cnt() const { + return stored_verdict_cnt_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000010u; + stored_verdict_cnt_ = value; +} +inline void LoginReputationClientRequest::set_stored_verdict_cnt(::PROTOBUF_NAMESPACE_ID::int32 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 = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || population_ != nullptr); + return value; +} +inline bool LoginReputationClientRequest::has_population() const { + return _internal_has_population(); +} +inline void LoginReputationClientRequest::clear_population() { + if (population_ != nullptr) population_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::safe_browsing::ChromeUserPopulation& LoginReputationClientRequest::_internal_population() const { + const ::safe_browsing::ChromeUserPopulation* p = 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 ::safe_browsing::ChromeUserPopulation* LoginReputationClientRequest::release_population() { + // @@protoc_insertion_point(field_release:safe_browsing.LoginReputationClientRequest.population) + _has_bits_[0] &= ~0x00000004u; + ::safe_browsing::ChromeUserPopulation* temp = population_; + population_ = nullptr; + return temp; +} +inline ::safe_browsing::ChromeUserPopulation* LoginReputationClientRequest::_internal_mutable_population() { + _has_bits_[0] |= 0x00000004u; + if (population_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ChromeUserPopulation>(GetArenaNoVirtual()); + population_ = p; + } + return population_; +} +inline ::safe_browsing::ChromeUserPopulation* LoginReputationClientRequest::mutable_population() { + // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientRequest.population) + return _internal_mutable_population(); +} +inline void LoginReputationClientRequest::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete population_; + } + if (population) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + population = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, population, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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 = (_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() { + clicked_through_interstitial_ = false; + _has_bits_[0] &= ~0x00000020u; +} +inline bool LoginReputationClientRequest::_internal_clicked_through_interstitial() const { + return 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) { + _has_bits_[0] |= 0x00000020u; + 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 = (_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() { + verdict_type_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline ::safe_browsing::LoginReputationClientResponse_VerdictType LoginReputationClientResponse::_internal_verdict_type() const { + return static_cast< ::safe_browsing::LoginReputationClientResponse_VerdictType >(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)); + _has_bits_[0] |= 0x00000008u; + 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 = (_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() { + cache_duration_sec_ = PROTOBUF_LONGLONG(0); + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 LoginReputationClientResponse::_internal_cache_duration_sec() const { + return cache_duration_sec_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 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(::PROTOBUF_NAMESPACE_ID::int64 value) { + _has_bits_[0] |= 0x00000004u; + cache_duration_sec_ = value; +} +inline void LoginReputationClientResponse::set_cache_duration_sec(::PROTOBUF_NAMESPACE_ID::int64 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 = (_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() { + cache_expression_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void LoginReputationClientResponse::set_cache_expression(const std::string& value) { + _internal_set_cache_expression(value); + // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientResponse.cache_expression) +} +inline std::string* LoginReputationClientResponse::mutable_cache_expression() { + // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientResponse.cache_expression) + return _internal_mutable_cache_expression(); +} +inline const std::string& LoginReputationClientResponse::_internal_cache_expression() const { + return cache_expression_.GetNoArena(); +} +inline void LoginReputationClientResponse::_internal_set_cache_expression(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + cache_expression_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void LoginReputationClientResponse::set_cache_expression(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + cache_expression_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.LoginReputationClientResponse.cache_expression) +} +inline void LoginReputationClientResponse::set_cache_expression(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + cache_expression_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.LoginReputationClientResponse.cache_expression) +} +inline void LoginReputationClientResponse::set_cache_expression(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + cache_expression_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.LoginReputationClientResponse.cache_expression) +} +inline std::string* LoginReputationClientResponse::_internal_mutable_cache_expression() { + _has_bits_[0] |= 0x00000001u; + return cache_expression_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* LoginReputationClientResponse::release_cache_expression() { + // @@protoc_insertion_point(field_release:safe_browsing.LoginReputationClientResponse.cache_expression) + if (!_internal_has_cache_expression()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return cache_expression_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void LoginReputationClientResponse::set_allocated_cache_expression(std::string* cache_expression) { + if (cache_expression != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + cache_expression_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cache_expression); + // @@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 = (_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() { + deprecated_cache_expression_exact_match_ = false; + _has_bits_[0] &= ~0x00000010u; +} +inline bool LoginReputationClientResponse::_internal_deprecated_cache_expression_exact_match() const { + return 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) { + _has_bits_[0] |= 0x00000010u; + 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 = (_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() { + verdict_token_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void LoginReputationClientResponse::set_verdict_token(const std::string& value) { + _internal_set_verdict_token(value); + // @@protoc_insertion_point(field_set:safe_browsing.LoginReputationClientResponse.verdict_token) +} +inline std::string* LoginReputationClientResponse::mutable_verdict_token() { + // @@protoc_insertion_point(field_mutable:safe_browsing.LoginReputationClientResponse.verdict_token) + return _internal_mutable_verdict_token(); +} +inline const std::string& LoginReputationClientResponse::_internal_verdict_token() const { + return verdict_token_.GetNoArena(); +} +inline void LoginReputationClientResponse::_internal_set_verdict_token(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + verdict_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void LoginReputationClientResponse::set_verdict_token(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + verdict_token_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.LoginReputationClientResponse.verdict_token) +} +inline void LoginReputationClientResponse::set_verdict_token(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + verdict_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.LoginReputationClientResponse.verdict_token) +} +inline void LoginReputationClientResponse::set_verdict_token(const void* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + verdict_token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.LoginReputationClientResponse.verdict_token) +} +inline std::string* LoginReputationClientResponse::_internal_mutable_verdict_token() { + _has_bits_[0] |= 0x00000002u; + return verdict_token_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* LoginReputationClientResponse::release_verdict_token() { + // @@protoc_insertion_point(field_release:safe_browsing.LoginReputationClientResponse.verdict_token) + if (!_internal_has_verdict_token()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return verdict_token_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void LoginReputationClientResponse::set_allocated_verdict_token(std::string* verdict_token) { + if (verdict_token != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + verdict_token_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), verdict_token); + // @@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 = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ClientMalwareResponse::has_blacklist() const { + return _internal_has_blacklist(); +} +inline void ClientMalwareResponse::clear_blacklist() { + blacklist_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool ClientMalwareResponse::_internal_blacklist() const { + return 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) { + _has_bits_[0] |= 0x00000004u; + 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 = (_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() { + bad_ip_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientMalwareResponse::set_bad_ip(const std::string& value) { + _internal_set_bad_ip(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareResponse.bad_ip) +} +inline std::string* ClientMalwareResponse::mutable_bad_ip() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareResponse.bad_ip) + return _internal_mutable_bad_ip(); +} +inline const std::string& ClientMalwareResponse::_internal_bad_ip() const { + return bad_ip_.GetNoArena(); +} +inline void ClientMalwareResponse::_internal_set_bad_ip(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + bad_ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientMalwareResponse::set_bad_ip(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + bad_ip_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientMalwareResponse.bad_ip) +} +inline void ClientMalwareResponse::set_bad_ip(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + bad_ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareResponse.bad_ip) +} +inline void ClientMalwareResponse::set_bad_ip(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + bad_ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareResponse.bad_ip) +} +inline std::string* ClientMalwareResponse::_internal_mutable_bad_ip() { + _has_bits_[0] |= 0x00000001u; + return bad_ip_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientMalwareResponse::release_bad_ip() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareResponse.bad_ip) + if (!_internal_has_bad_ip()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return bad_ip_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientMalwareResponse::set_allocated_bad_ip(std::string* bad_ip) { + if (bad_ip != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + bad_ip_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bad_ip); + // @@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 = (_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() { + bad_url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientMalwareResponse::set_bad_url(const std::string& value) { + _internal_set_bad_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareResponse.bad_url) +} +inline std::string* ClientMalwareResponse::mutable_bad_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareResponse.bad_url) + return _internal_mutable_bad_url(); +} +inline const std::string& ClientMalwareResponse::_internal_bad_url() const { + return bad_url_.GetNoArena(); +} +inline void ClientMalwareResponse::_internal_set_bad_url(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + bad_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientMalwareResponse::set_bad_url(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + bad_url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientMalwareResponse.bad_url) +} +inline void ClientMalwareResponse::set_bad_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + bad_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareResponse.bad_url) +} +inline void ClientMalwareResponse::set_bad_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + bad_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareResponse.bad_url) +} +inline std::string* ClientMalwareResponse::_internal_mutable_bad_url() { + _has_bits_[0] |= 0x00000002u; + return bad_url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientMalwareResponse::release_bad_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientMalwareResponse.bad_url) + if (!_internal_has_bad_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return bad_url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientMalwareResponse::set_allocated_bad_url(std::string* bad_url) { + if (bad_url != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + bad_url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bad_url); + // @@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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientDownloadRequest_Digests::has_sha256() const { + return _internal_has_sha256(); +} +inline void ClientDownloadRequest_Digests::clear_sha256() { + sha256_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_Digests::set_sha256(const std::string& value) { + _internal_set_sha256(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Digests.sha256) +} +inline std::string* ClientDownloadRequest_Digests::mutable_sha256() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Digests.sha256) + return _internal_mutable_sha256(); +} +inline const std::string& ClientDownloadRequest_Digests::_internal_sha256() const { + return sha256_.GetNoArena(); +} +inline void ClientDownloadRequest_Digests::_internal_set_sha256(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + sha256_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_Digests::set_sha256(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + sha256_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.Digests.sha256) +} +inline void ClientDownloadRequest_Digests::set_sha256(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + sha256_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.Digests.sha256) +} +inline void ClientDownloadRequest_Digests::set_sha256(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + sha256_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.Digests.sha256) +} +inline std::string* ClientDownloadRequest_Digests::_internal_mutable_sha256() { + _has_bits_[0] |= 0x00000001u; + return sha256_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadRequest_Digests::release_sha256() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.Digests.sha256) + if (!_internal_has_sha256()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return sha256_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_Digests::set_allocated_sha256(std::string* sha256) { + if (sha256 != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + sha256_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sha256); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientDownloadRequest_Digests::has_sha1() const { + return _internal_has_sha1(); +} +inline void ClientDownloadRequest_Digests::clear_sha1() { + sha1_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_Digests::set_sha1(const std::string& value) { + _internal_set_sha1(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Digests.sha1) +} +inline std::string* ClientDownloadRequest_Digests::mutable_sha1() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Digests.sha1) + return _internal_mutable_sha1(); +} +inline const std::string& ClientDownloadRequest_Digests::_internal_sha1() const { + return sha1_.GetNoArena(); +} +inline void ClientDownloadRequest_Digests::_internal_set_sha1(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + sha1_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_Digests::set_sha1(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + sha1_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.Digests.sha1) +} +inline void ClientDownloadRequest_Digests::set_sha1(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + sha1_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.Digests.sha1) +} +inline void ClientDownloadRequest_Digests::set_sha1(const void* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + sha1_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.Digests.sha1) +} +inline std::string* ClientDownloadRequest_Digests::_internal_mutable_sha1() { + _has_bits_[0] |= 0x00000002u; + return sha1_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadRequest_Digests::release_sha1() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.Digests.sha1) + if (!_internal_has_sha1()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return sha1_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_Digests::set_allocated_sha1(std::string* sha1) { + if (sha1 != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + sha1_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sha1); + // @@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 = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ClientDownloadRequest_Digests::has_md5() const { + return _internal_has_md5(); +} +inline void ClientDownloadRequest_Digests::clear_md5() { + md5_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_Digests::set_md5(const std::string& value) { + _internal_set_md5(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Digests.md5) +} +inline std::string* ClientDownloadRequest_Digests::mutable_md5() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Digests.md5) + return _internal_mutable_md5(); +} +inline const std::string& ClientDownloadRequest_Digests::_internal_md5() const { + return md5_.GetNoArena(); +} +inline void ClientDownloadRequest_Digests::_internal_set_md5(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + md5_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_Digests::set_md5(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + md5_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.Digests.md5) +} +inline void ClientDownloadRequest_Digests::set_md5(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + md5_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.Digests.md5) +} +inline void ClientDownloadRequest_Digests::set_md5(const void* value, size_t size) { + _has_bits_[0] |= 0x00000004u; + md5_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.Digests.md5) +} +inline std::string* ClientDownloadRequest_Digests::_internal_mutable_md5() { + _has_bits_[0] |= 0x00000004u; + return md5_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadRequest_Digests::release_md5() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.Digests.md5) + if (!_internal_has_md5()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + return md5_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_Digests::set_allocated_md5(std::string* md5) { + if (md5 != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + md5_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), md5); + // @@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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientDownloadRequest_Resource::has_url() const { + return _internal_has_url(); +} +inline void ClientDownloadRequest_Resource::clear_url() { + url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_Resource::set_url(const std::string& value) { + _internal_set_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Resource.url) +} +inline std::string* ClientDownloadRequest_Resource::mutable_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Resource.url) + return _internal_mutable_url(); +} +inline const std::string& ClientDownloadRequest_Resource::_internal_url() const { + return url_.GetNoArena(); +} +inline void ClientDownloadRequest_Resource::_internal_set_url(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_Resource::set_url(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.Resource.url) +} +inline void ClientDownloadRequest_Resource::set_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.Resource.url) +} +inline void ClientDownloadRequest_Resource::set_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.Resource.url) +} +inline std::string* ClientDownloadRequest_Resource::_internal_mutable_url() { + _has_bits_[0] |= 0x00000001u; + return url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadRequest_Resource::release_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.Resource.url) + if (!_internal_has_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_Resource::set_allocated_url(std::string* url) { + if (url != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url); + // @@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 = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ClientDownloadRequest_Resource::has_type() const { + return _internal_has_type(); +} +inline void ClientDownloadRequest_Resource::clear_type() { + type_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline ::safe_browsing::ClientDownloadRequest_ResourceType ClientDownloadRequest_Resource::_internal_type() const { + return static_cast< ::safe_browsing::ClientDownloadRequest_ResourceType >(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)); + _has_bits_[0] |= 0x00000008u; + 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 = (_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() { + remote_ip_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_Resource::set_remote_ip(const std::string& value) { + _internal_set_remote_ip(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Resource.remote_ip) +} +inline std::string* ClientDownloadRequest_Resource::mutable_remote_ip() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Resource.remote_ip) + return _internal_mutable_remote_ip(); +} +inline const std::string& ClientDownloadRequest_Resource::_internal_remote_ip() const { + return remote_ip_.GetNoArena(); +} +inline void ClientDownloadRequest_Resource::_internal_set_remote_ip(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + remote_ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_Resource::set_remote_ip(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + remote_ip_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.Resource.remote_ip) +} +inline void ClientDownloadRequest_Resource::set_remote_ip(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + remote_ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.Resource.remote_ip) +} +inline void ClientDownloadRequest_Resource::set_remote_ip(const void* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + remote_ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.Resource.remote_ip) +} +inline std::string* ClientDownloadRequest_Resource::_internal_mutable_remote_ip() { + _has_bits_[0] |= 0x00000002u; + return remote_ip_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return remote_ip_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_Resource::set_allocated_remote_ip(std::string* remote_ip) { + if (remote_ip != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + remote_ip_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), remote_ip); + // @@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 = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ClientDownloadRequest_Resource::has_referrer() const { + return _internal_has_referrer(); +} +inline void ClientDownloadRequest_Resource::clear_referrer() { + referrer_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_Resource::set_referrer(const std::string& value) { + _internal_set_referrer(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Resource.referrer) +} +inline std::string* ClientDownloadRequest_Resource::mutable_referrer() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Resource.referrer) + return _internal_mutable_referrer(); +} +inline const std::string& ClientDownloadRequest_Resource::_internal_referrer() const { + return referrer_.GetNoArena(); +} +inline void ClientDownloadRequest_Resource::_internal_set_referrer(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + referrer_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_Resource::set_referrer(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + referrer_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.Resource.referrer) +} +inline void ClientDownloadRequest_Resource::set_referrer(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + referrer_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.Resource.referrer) +} +inline void ClientDownloadRequest_Resource::set_referrer(const char* value, size_t size) { + _has_bits_[0] |= 0x00000004u; + referrer_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.Resource.referrer) +} +inline std::string* ClientDownloadRequest_Resource::_internal_mutable_referrer() { + _has_bits_[0] |= 0x00000004u; + return referrer_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadRequest_Resource::release_referrer() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.Resource.referrer) + if (!_internal_has_referrer()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + return referrer_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_Resource::set_allocated_referrer(std::string* referrer) { + if (referrer != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + referrer_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), referrer); + // @@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 = (_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() { + certificate_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_CertificateChain_Element::set_certificate(const std::string& value) { + _internal_set_certificate(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate) +} +inline std::string* ClientDownloadRequest_CertificateChain_Element::mutable_certificate() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate) + return _internal_mutable_certificate(); +} +inline const std::string& ClientDownloadRequest_CertificateChain_Element::_internal_certificate() const { + return certificate_.GetNoArena(); +} +inline void ClientDownloadRequest_CertificateChain_Element::_internal_set_certificate(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + certificate_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_CertificateChain_Element::set_certificate(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + certificate_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate) +} +inline void ClientDownloadRequest_CertificateChain_Element::set_certificate(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + certificate_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate) +} +inline void ClientDownloadRequest_CertificateChain_Element::set_certificate(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + certificate_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate) +} +inline std::string* ClientDownloadRequest_CertificateChain_Element::_internal_mutable_certificate() { + _has_bits_[0] |= 0x00000001u; + return certificate_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return certificate_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_CertificateChain_Element::set_allocated_certificate(std::string* certificate) { + if (certificate != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + certificate_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate); + // @@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 element_.size(); +} +inline int ClientDownloadRequest_CertificateChain::element_size() const { + return _internal_element_size(); +} +inline void ClientDownloadRequest_CertificateChain::clear_element() { + 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 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 &element_; +} +inline const ::safe_browsing::ClientDownloadRequest_CertificateChain_Element& ClientDownloadRequest_CertificateChain::_internal_element(int index) const { + return 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 element_.Add(); +} +inline ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* ClientDownloadRequest_CertificateChain::add_element() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.CertificateChain.element) + return _internal_add_element(); +} +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 element_; +} + +// ------------------------------------------------------------------- + +// ClientDownloadRequest_ExtendedAttr + +// required string key = 1; +inline bool ClientDownloadRequest_ExtendedAttr::_internal_has_key() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientDownloadRequest_ExtendedAttr::has_key() const { + return _internal_has_key(); +} +inline void ClientDownloadRequest_ExtendedAttr::clear_key() { + key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_ExtendedAttr::set_key(const std::string& value) { + _internal_set_key(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.ExtendedAttr.key) +} +inline std::string* ClientDownloadRequest_ExtendedAttr::mutable_key() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ExtendedAttr.key) + return _internal_mutable_key(); +} +inline const std::string& ClientDownloadRequest_ExtendedAttr::_internal_key() const { + return key_.GetNoArena(); +} +inline void ClientDownloadRequest_ExtendedAttr::_internal_set_key(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_ExtendedAttr::set_key(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + key_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.ExtendedAttr.key) +} +inline void ClientDownloadRequest_ExtendedAttr::set_key(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.ExtendedAttr.key) +} +inline void ClientDownloadRequest_ExtendedAttr::set_key(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.ExtendedAttr.key) +} +inline std::string* ClientDownloadRequest_ExtendedAttr::_internal_mutable_key() { + _has_bits_[0] |= 0x00000001u; + return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadRequest_ExtendedAttr::release_key() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.ExtendedAttr.key) + if (!_internal_has_key()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return key_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_ExtendedAttr::set_allocated_key(std::string* key) { + if (key != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientDownloadRequest_ExtendedAttr::has_value() const { + return _internal_has_value(); +} +inline void ClientDownloadRequest_ExtendedAttr::clear_value() { + value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_ExtendedAttr::set_value(const std::string& value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.ExtendedAttr.value) +} +inline std::string* ClientDownloadRequest_ExtendedAttr::mutable_value() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ExtendedAttr.value) + return _internal_mutable_value(); +} +inline const std::string& ClientDownloadRequest_ExtendedAttr::_internal_value() const { + return value_.GetNoArena(); +} +inline void ClientDownloadRequest_ExtendedAttr::_internal_set_value(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_ExtendedAttr::set_value(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + value_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.ExtendedAttr.value) +} +inline void ClientDownloadRequest_ExtendedAttr::set_value(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.ExtendedAttr.value) +} +inline void ClientDownloadRequest_ExtendedAttr::set_value(const void* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.ExtendedAttr.value) +} +inline std::string* ClientDownloadRequest_ExtendedAttr::_internal_mutable_value() { + _has_bits_[0] |= 0x00000002u; + return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadRequest_ExtendedAttr::release_value() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.ExtendedAttr.value) + if (!_internal_has_value()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return value_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_ExtendedAttr::set_allocated_value(std::string* value) { + if (value != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@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 certificate_chain_.size(); +} +inline int ClientDownloadRequest_SignatureInfo::certificate_chain_size() const { + return _internal_certificate_chain_size(); +} +inline void ClientDownloadRequest_SignatureInfo::clear_certificate_chain() { + 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 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 &certificate_chain_; +} +inline const ::safe_browsing::ClientDownloadRequest_CertificateChain& ClientDownloadRequest_SignatureInfo::_internal_certificate_chain(int index) const { + return 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 certificate_chain_.Add(); +} +inline ::safe_browsing::ClientDownloadRequest_CertificateChain* ClientDownloadRequest_SignatureInfo::add_certificate_chain() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.SignatureInfo.certificate_chain) + return _internal_add_certificate_chain(); +} +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 certificate_chain_; +} + +// optional bool trusted = 2; +inline bool ClientDownloadRequest_SignatureInfo::_internal_has_trusted() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientDownloadRequest_SignatureInfo::has_trusted() const { + return _internal_has_trusted(); +} +inline void ClientDownloadRequest_SignatureInfo::clear_trusted() { + trusted_ = false; + _has_bits_[0] &= ~0x00000001u; +} +inline bool ClientDownloadRequest_SignatureInfo::_internal_trusted() const { + return 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) { + _has_bits_[0] |= 0x00000001u; + 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 signed_data_.size(); +} +inline int ClientDownloadRequest_SignatureInfo::signed_data_size() const { + return _internal_signed_data_size(); +} +inline void ClientDownloadRequest_SignatureInfo::clear_signed_data() { + signed_data_.Clear(); +} +inline std::string* ClientDownloadRequest_SignatureInfo::add_signed_data() { + // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data) + return _internal_add_signed_data(); +} +inline const std::string& ClientDownloadRequest_SignatureInfo::_internal_signed_data(int index) const { + return 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 signed_data_.Mutable(index); +} +inline void ClientDownloadRequest_SignatureInfo::set_signed_data(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data) + signed_data_.Mutable(index)->assign(value); +} +inline void ClientDownloadRequest_SignatureInfo::set_signed_data(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data) + signed_data_.Mutable(index)->assign(std::move(value)); +} +inline void ClientDownloadRequest_SignatureInfo::set_signed_data(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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) { + 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 signed_data_.Add(); +} +inline void ClientDownloadRequest_SignatureInfo::add_signed_data(const std::string& value) { + 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) { + 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); + 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) { + 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 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 &signed_data_; +} + +// repeated .safe_browsing.ClientDownloadRequest.ExtendedAttr xattr = 4; +inline int ClientDownloadRequest_SignatureInfo::_internal_xattr_size() const { + return xattr_.size(); +} +inline int ClientDownloadRequest_SignatureInfo::xattr_size() const { + return _internal_xattr_size(); +} +inline void ClientDownloadRequest_SignatureInfo::clear_xattr() { + xattr_.Clear(); +} +inline ::safe_browsing::ClientDownloadRequest_ExtendedAttr* ClientDownloadRequest_SignatureInfo::mutable_xattr(int index) { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.SignatureInfo.xattr) + return 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 &xattr_; +} +inline const ::safe_browsing::ClientDownloadRequest_ExtendedAttr& ClientDownloadRequest_SignatureInfo::_internal_xattr(int index) const { + return 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 xattr_.Add(); +} +inline ::safe_browsing::ClientDownloadRequest_ExtendedAttr* ClientDownloadRequest_SignatureInfo::add_xattr() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.SignatureInfo.xattr) + return _internal_add_xattr(); +} +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 xattr_; +} + +// ------------------------------------------------------------------- + +// ClientDownloadRequest_PEImageHeaders_DebugData + +// optional bytes directory_entry = 1; +inline bool ClientDownloadRequest_PEImageHeaders_DebugData::_internal_has_directory_entry() const { + bool value = (_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() { + directory_entry_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_directory_entry(const std::string& value) { + _internal_set_directory_entry(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry) +} +inline std::string* ClientDownloadRequest_PEImageHeaders_DebugData::mutable_directory_entry() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry) + return _internal_mutable_directory_entry(); +} +inline const std::string& ClientDownloadRequest_PEImageHeaders_DebugData::_internal_directory_entry() const { + return directory_entry_.GetNoArena(); +} +inline void ClientDownloadRequest_PEImageHeaders_DebugData::_internal_set_directory_entry(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + directory_entry_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_directory_entry(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + directory_entry_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry) +} +inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_directory_entry(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + directory_entry_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry) +} +inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_directory_entry(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + directory_entry_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry) +} +inline std::string* ClientDownloadRequest_PEImageHeaders_DebugData::_internal_mutable_directory_entry() { + _has_bits_[0] |= 0x00000001u; + return directory_entry_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return directory_entry_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_allocated_directory_entry(std::string* directory_entry) { + if (directory_entry != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + directory_entry_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), directory_entry); + // @@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 = (_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() { + raw_data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_raw_data(const std::string& value) { + _internal_set_raw_data(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data) +} +inline std::string* ClientDownloadRequest_PEImageHeaders_DebugData::mutable_raw_data() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data) + return _internal_mutable_raw_data(); +} +inline const std::string& ClientDownloadRequest_PEImageHeaders_DebugData::_internal_raw_data() const { + return raw_data_.GetNoArena(); +} +inline void ClientDownloadRequest_PEImageHeaders_DebugData::_internal_set_raw_data(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + raw_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_raw_data(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + raw_data_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data) +} +inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_raw_data(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + raw_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data) +} +inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_raw_data(const void* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + raw_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data) +} +inline std::string* ClientDownloadRequest_PEImageHeaders_DebugData::_internal_mutable_raw_data() { + _has_bits_[0] |= 0x00000002u; + return raw_data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return raw_data_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_allocated_raw_data(std::string* raw_data) { + if (raw_data != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + raw_data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), raw_data); + // @@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 = (_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() { + dos_header_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_PEImageHeaders::set_dos_header(const std::string& value) { + _internal_set_dos_header(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header) +} +inline std::string* ClientDownloadRequest_PEImageHeaders::mutable_dos_header() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header) + return _internal_mutable_dos_header(); +} +inline const std::string& ClientDownloadRequest_PEImageHeaders::_internal_dos_header() const { + return dos_header_.GetNoArena(); +} +inline void ClientDownloadRequest_PEImageHeaders::_internal_set_dos_header(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + dos_header_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_PEImageHeaders::set_dos_header(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + dos_header_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header) +} +inline void ClientDownloadRequest_PEImageHeaders::set_dos_header(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + dos_header_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header) +} +inline void ClientDownloadRequest_PEImageHeaders::set_dos_header(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + dos_header_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header) +} +inline std::string* ClientDownloadRequest_PEImageHeaders::_internal_mutable_dos_header() { + _has_bits_[0] |= 0x00000001u; + return dos_header_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return dos_header_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_PEImageHeaders::set_allocated_dos_header(std::string* dos_header) { + if (dos_header != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + dos_header_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dos_header); + // @@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 = (_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() { + file_header_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_PEImageHeaders::set_file_header(const std::string& value) { + _internal_set_file_header(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header) +} +inline std::string* ClientDownloadRequest_PEImageHeaders::mutable_file_header() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header) + return _internal_mutable_file_header(); +} +inline const std::string& ClientDownloadRequest_PEImageHeaders::_internal_file_header() const { + return file_header_.GetNoArena(); +} +inline void ClientDownloadRequest_PEImageHeaders::_internal_set_file_header(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + file_header_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_PEImageHeaders::set_file_header(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + file_header_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header) +} +inline void ClientDownloadRequest_PEImageHeaders::set_file_header(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + file_header_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header) +} +inline void ClientDownloadRequest_PEImageHeaders::set_file_header(const void* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + file_header_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header) +} +inline std::string* ClientDownloadRequest_PEImageHeaders::_internal_mutable_file_header() { + _has_bits_[0] |= 0x00000002u; + return file_header_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return file_header_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_PEImageHeaders::set_allocated_file_header(std::string* file_header) { + if (file_header != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + file_header_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), file_header); + // @@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 = (_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() { + optional_headers32_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_PEImageHeaders::set_optional_headers32(const std::string& value) { + _internal_set_optional_headers32(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32) +} +inline std::string* ClientDownloadRequest_PEImageHeaders::mutable_optional_headers32() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32) + return _internal_mutable_optional_headers32(); +} +inline const std::string& ClientDownloadRequest_PEImageHeaders::_internal_optional_headers32() const { + return optional_headers32_.GetNoArena(); +} +inline void ClientDownloadRequest_PEImageHeaders::_internal_set_optional_headers32(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + optional_headers32_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_PEImageHeaders::set_optional_headers32(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + optional_headers32_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32) +} +inline void ClientDownloadRequest_PEImageHeaders::set_optional_headers32(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + optional_headers32_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32) +} +inline void ClientDownloadRequest_PEImageHeaders::set_optional_headers32(const void* value, size_t size) { + _has_bits_[0] |= 0x00000004u; + optional_headers32_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32) +} +inline std::string* ClientDownloadRequest_PEImageHeaders::_internal_mutable_optional_headers32() { + _has_bits_[0] |= 0x00000004u; + return optional_headers32_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000004u; + return optional_headers32_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_PEImageHeaders::set_allocated_optional_headers32(std::string* optional_headers32) { + if (optional_headers32 != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + optional_headers32_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), optional_headers32); + // @@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 = (_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() { + optional_headers64_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_PEImageHeaders::set_optional_headers64(const std::string& value) { + _internal_set_optional_headers64(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64) +} +inline std::string* ClientDownloadRequest_PEImageHeaders::mutable_optional_headers64() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64) + return _internal_mutable_optional_headers64(); +} +inline const std::string& ClientDownloadRequest_PEImageHeaders::_internal_optional_headers64() const { + return optional_headers64_.GetNoArena(); +} +inline void ClientDownloadRequest_PEImageHeaders::_internal_set_optional_headers64(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + optional_headers64_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_PEImageHeaders::set_optional_headers64(std::string&& value) { + _has_bits_[0] |= 0x00000008u; + optional_headers64_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64) +} +inline void ClientDownloadRequest_PEImageHeaders::set_optional_headers64(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000008u; + optional_headers64_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64) +} +inline void ClientDownloadRequest_PEImageHeaders::set_optional_headers64(const void* value, size_t size) { + _has_bits_[0] |= 0x00000008u; + optional_headers64_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64) +} +inline std::string* ClientDownloadRequest_PEImageHeaders::_internal_mutable_optional_headers64() { + _has_bits_[0] |= 0x00000008u; + return optional_headers64_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000008u; + return optional_headers64_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_PEImageHeaders::set_allocated_optional_headers64(std::string* optional_headers64) { + if (optional_headers64 != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + optional_headers64_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), optional_headers64); + // @@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 section_header_.size(); +} +inline int ClientDownloadRequest_PEImageHeaders::section_header_size() const { + return _internal_section_header_size(); +} +inline void ClientDownloadRequest_PEImageHeaders::clear_section_header() { + section_header_.Clear(); +} +inline std::string* ClientDownloadRequest_PEImageHeaders::add_section_header() { + // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header) + return _internal_add_section_header(); +} +inline const std::string& ClientDownloadRequest_PEImageHeaders::_internal_section_header(int index) const { + return 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 section_header_.Mutable(index); +} +inline void ClientDownloadRequest_PEImageHeaders::set_section_header(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header) + section_header_.Mutable(index)->assign(value); +} +inline void ClientDownloadRequest_PEImageHeaders::set_section_header(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header) + section_header_.Mutable(index)->assign(std::move(value)); +} +inline void ClientDownloadRequest_PEImageHeaders::set_section_header(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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) { + 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 section_header_.Add(); +} +inline void ClientDownloadRequest_PEImageHeaders::add_section_header(const std::string& value) { + 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) { + 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); + 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) { + 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 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 §ion_header_; +} + +// optional bytes export_section_data = 6; +inline bool ClientDownloadRequest_PEImageHeaders::_internal_has_export_section_data() const { + bool value = (_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() { + export_section_data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_PEImageHeaders::set_export_section_data(const std::string& value) { + _internal_set_export_section_data(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data) +} +inline std::string* ClientDownloadRequest_PEImageHeaders::mutable_export_section_data() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data) + return _internal_mutable_export_section_data(); +} +inline const std::string& ClientDownloadRequest_PEImageHeaders::_internal_export_section_data() const { + return export_section_data_.GetNoArena(); +} +inline void ClientDownloadRequest_PEImageHeaders::_internal_set_export_section_data(const std::string& value) { + _has_bits_[0] |= 0x00000010u; + export_section_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_PEImageHeaders::set_export_section_data(std::string&& value) { + _has_bits_[0] |= 0x00000010u; + export_section_data_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data) +} +inline void ClientDownloadRequest_PEImageHeaders::set_export_section_data(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000010u; + export_section_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data) +} +inline void ClientDownloadRequest_PEImageHeaders::set_export_section_data(const void* value, size_t size) { + _has_bits_[0] |= 0x00000010u; + export_section_data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data) +} +inline std::string* ClientDownloadRequest_PEImageHeaders::_internal_mutable_export_section_data() { + _has_bits_[0] |= 0x00000010u; + return export_section_data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000010u; + return export_section_data_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_PEImageHeaders::set_allocated_export_section_data(std::string* export_section_data) { + if (export_section_data != nullptr) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + export_section_data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), export_section_data); + // @@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 debug_data_.size(); +} +inline int ClientDownloadRequest_PEImageHeaders::debug_data_size() const { + return _internal_debug_data_size(); +} +inline void ClientDownloadRequest_PEImageHeaders::clear_debug_data() { + 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 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 &debug_data_; +} +inline const ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData& ClientDownloadRequest_PEImageHeaders::_internal_debug_data(int index) const { + return 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 debug_data_.Add(); +} +inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData* ClientDownloadRequest_PEImageHeaders::add_debug_data() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.PEImageHeaders.debug_data) + return _internal_add_debug_data(); +} +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 debug_data_; +} + +// ------------------------------------------------------------------- + +// ClientDownloadRequest_MachOHeaders_LoadCommand + +// required uint32 command_id = 1; +inline bool ClientDownloadRequest_MachOHeaders_LoadCommand::_internal_has_command_id() const { + bool value = (_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() { + command_id_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientDownloadRequest_MachOHeaders_LoadCommand::_internal_command_id() const { + return command_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 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(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + command_id_ = value; +} +inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_command_id(::PROTOBUF_NAMESPACE_ID::uint32 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 = (_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() { + command_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_command(const std::string& value) { + _internal_set_command(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command) +} +inline std::string* ClientDownloadRequest_MachOHeaders_LoadCommand::mutable_command() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command) + return _internal_mutable_command(); +} +inline const std::string& ClientDownloadRequest_MachOHeaders_LoadCommand::_internal_command() const { + return command_.GetNoArena(); +} +inline void ClientDownloadRequest_MachOHeaders_LoadCommand::_internal_set_command(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + command_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_command(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + command_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command) +} +inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_command(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + command_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command) +} +inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_command(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + command_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command) +} +inline std::string* ClientDownloadRequest_MachOHeaders_LoadCommand::_internal_mutable_command() { + _has_bits_[0] |= 0x00000001u; + return command_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return command_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_allocated_command(std::string* command) { + if (command != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + command_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), command); + // @@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 = (_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() { + mach_header_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_MachOHeaders::set_mach_header(const std::string& value) { + _internal_set_mach_header(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header) +} +inline std::string* ClientDownloadRequest_MachOHeaders::mutable_mach_header() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header) + return _internal_mutable_mach_header(); +} +inline const std::string& ClientDownloadRequest_MachOHeaders::_internal_mach_header() const { + return mach_header_.GetNoArena(); +} +inline void ClientDownloadRequest_MachOHeaders::_internal_set_mach_header(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + mach_header_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_MachOHeaders::set_mach_header(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + mach_header_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header) +} +inline void ClientDownloadRequest_MachOHeaders::set_mach_header(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + mach_header_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header) +} +inline void ClientDownloadRequest_MachOHeaders::set_mach_header(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + mach_header_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header) +} +inline std::string* ClientDownloadRequest_MachOHeaders::_internal_mutable_mach_header() { + _has_bits_[0] |= 0x00000001u; + return mach_header_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return mach_header_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_MachOHeaders::set_allocated_mach_header(std::string* mach_header) { + if (mach_header != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + mach_header_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mach_header); + // @@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 load_commands_.size(); +} +inline int ClientDownloadRequest_MachOHeaders::load_commands_size() const { + return _internal_load_commands_size(); +} +inline void ClientDownloadRequest_MachOHeaders::clear_load_commands() { + 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 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 &load_commands_; +} +inline const ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand& ClientDownloadRequest_MachOHeaders::_internal_load_commands(int index) const { + return 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 load_commands_.Add(); +} +inline ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand* ClientDownloadRequest_MachOHeaders::add_load_commands() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.MachOHeaders.load_commands) + return _internal_add_load_commands(); +} +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 load_commands_; +} + +// ------------------------------------------------------------------- + +// ClientDownloadRequest_ImageHeaders + +// optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1; +inline bool ClientDownloadRequest_ImageHeaders::_internal_has_pe_headers() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || 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 (pe_headers_ != nullptr) pe_headers_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::safe_browsing::ClientDownloadRequest_PEImageHeaders& ClientDownloadRequest_ImageHeaders::_internal_pe_headers() const { + const ::safe_browsing::ClientDownloadRequest_PEImageHeaders* p = 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 ::safe_browsing::ClientDownloadRequest_PEImageHeaders* ClientDownloadRequest_ImageHeaders::release_pe_headers() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.ImageHeaders.pe_headers) + _has_bits_[0] &= ~0x00000001u; + ::safe_browsing::ClientDownloadRequest_PEImageHeaders* temp = pe_headers_; + pe_headers_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders* ClientDownloadRequest_ImageHeaders::_internal_mutable_pe_headers() { + _has_bits_[0] |= 0x00000001u; + if (pe_headers_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_PEImageHeaders>(GetArenaNoVirtual()); + pe_headers_ = p; + } + return pe_headers_; +} +inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders* ClientDownloadRequest_ImageHeaders::mutable_pe_headers() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ImageHeaders.pe_headers) + return _internal_mutable_pe_headers(); +} +inline void ClientDownloadRequest_ImageHeaders::set_allocated_pe_headers(::safe_browsing::ClientDownloadRequest_PEImageHeaders* pe_headers) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete pe_headers_; + } + if (pe_headers) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + pe_headers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, pe_headers, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + 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 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() { + 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 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 &mach_o_headers_; +} +inline const ::safe_browsing::ClientDownloadRequest_MachOHeaders& ClientDownloadRequest_ImageHeaders::_internal_mach_o_headers(int index) const { + return 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 mach_o_headers_.Add(); +} +inline ::safe_browsing::ClientDownloadRequest_MachOHeaders* ClientDownloadRequest_ImageHeaders::add_mach_o_headers() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.ImageHeaders.mach_o_headers) + return _internal_add_mach_o_headers(); +} +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 mach_o_headers_; +} + +// ------------------------------------------------------------------- + +// ClientDownloadRequest_ArchivedBinary + +// optional string file_basename = 1; +inline bool ClientDownloadRequest_ArchivedBinary::_internal_has_file_basename() const { + bool value = (_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() { + file_basename_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest_ArchivedBinary::set_file_basename(const std::string& value) { + _internal_set_file_basename(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename) +} +inline std::string* ClientDownloadRequest_ArchivedBinary::mutable_file_basename() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename) + return _internal_mutable_file_basename(); +} +inline const std::string& ClientDownloadRequest_ArchivedBinary::_internal_file_basename() const { + return file_basename_.GetNoArena(); +} +inline void ClientDownloadRequest_ArchivedBinary::_internal_set_file_basename(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + file_basename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest_ArchivedBinary::set_file_basename(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + file_basename_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename) +} +inline void ClientDownloadRequest_ArchivedBinary::set_file_basename(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + file_basename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename) +} +inline void ClientDownloadRequest_ArchivedBinary::set_file_basename(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + file_basename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename) +} +inline std::string* ClientDownloadRequest_ArchivedBinary::_internal_mutable_file_basename() { + _has_bits_[0] |= 0x00000001u; + return file_basename_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return file_basename_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest_ArchivedBinary::set_allocated_file_basename(std::string* file_basename) { + if (file_basename != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + file_basename_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), file_basename); + // @@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 = (_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() { + download_type_ = 0; + _has_bits_[0] &= ~0x00000020u; +} +inline ::safe_browsing::ClientDownloadRequest_DownloadType ClientDownloadRequest_ArchivedBinary::_internal_download_type() const { + return static_cast< ::safe_browsing::ClientDownloadRequest_DownloadType >(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)); + _has_bits_[0] |= 0x00000020u; + 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 = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || digests_ != nullptr); + return value; +} +inline bool ClientDownloadRequest_ArchivedBinary::has_digests() const { + return _internal_has_digests(); +} +inline void ClientDownloadRequest_ArchivedBinary::clear_digests() { + if (digests_ != nullptr) digests_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::safe_browsing::ClientDownloadRequest_Digests& ClientDownloadRequest_ArchivedBinary::_internal_digests() const { + const ::safe_browsing::ClientDownloadRequest_Digests* p = 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 ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest_ArchivedBinary::release_digests() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.ArchivedBinary.digests) + _has_bits_[0] &= ~0x00000002u; + ::safe_browsing::ClientDownloadRequest_Digests* temp = digests_; + digests_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest_ArchivedBinary::_internal_mutable_digests() { + _has_bits_[0] |= 0x00000002u; + if (digests_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_Digests>(GetArenaNoVirtual()); + digests_ = p; + } + return digests_; +} +inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest_ArchivedBinary::mutable_digests() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ArchivedBinary.digests) + return _internal_mutable_digests(); +} +inline void ClientDownloadRequest_ArchivedBinary::set_allocated_digests(::safe_browsing::ClientDownloadRequest_Digests* digests) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete digests_; + } + if (digests) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + digests = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, digests, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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 = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ClientDownloadRequest_ArchivedBinary::has_length() const { + return _internal_has_length(); +} +inline void ClientDownloadRequest_ArchivedBinary::clear_length() { + length_ = PROTOBUF_LONGLONG(0); + _has_bits_[0] &= ~0x00000010u; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ClientDownloadRequest_ArchivedBinary::_internal_length() const { + return length_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ClientDownloadRequest_ArchivedBinary::length() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ArchivedBinary.length) + return _internal_length(); +} +inline void ClientDownloadRequest_ArchivedBinary::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int64 value) { + _has_bits_[0] |= 0x00000010u; + length_ = value; +} +inline void ClientDownloadRequest_ArchivedBinary::set_length(::PROTOBUF_NAMESPACE_ID::int64 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 = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || signature_ != nullptr); + return value; +} +inline bool ClientDownloadRequest_ArchivedBinary::has_signature() const { + return _internal_has_signature(); +} +inline void ClientDownloadRequest_ArchivedBinary::clear_signature() { + if (signature_ != nullptr) signature_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientDownloadRequest_ArchivedBinary::_internal_signature() const { + const ::safe_browsing::ClientDownloadRequest_SignatureInfo* p = 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 ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest_ArchivedBinary::release_signature() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.ArchivedBinary.signature) + _has_bits_[0] &= ~0x00000004u; + ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = signature_; + signature_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest_ArchivedBinary::_internal_mutable_signature() { + _has_bits_[0] |= 0x00000004u; + if (signature_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_SignatureInfo>(GetArenaNoVirtual()); + signature_ = p; + } + return signature_; +} +inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest_ArchivedBinary::mutable_signature() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ArchivedBinary.signature) + return _internal_mutable_signature(); +} +inline void ClientDownloadRequest_ArchivedBinary::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete signature_; + } + if (signature) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + signature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, signature, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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 = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || 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 (image_headers_ != nullptr) image_headers_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientDownloadRequest_ArchivedBinary::_internal_image_headers() const { + const ::safe_browsing::ClientDownloadRequest_ImageHeaders* p = 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 ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest_ArchivedBinary::release_image_headers() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.ArchivedBinary.image_headers) + _has_bits_[0] &= ~0x00000008u; + ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = image_headers_; + image_headers_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest_ArchivedBinary::_internal_mutable_image_headers() { + _has_bits_[0] |= 0x00000008u; + if (image_headers_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_ImageHeaders>(GetArenaNoVirtual()); + image_headers_ = p; + } + return image_headers_; +} +inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest_ArchivedBinary::mutable_image_headers() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ArchivedBinary.image_headers) + return _internal_mutable_image_headers(); +} +inline void ClientDownloadRequest_ArchivedBinary::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete image_headers_; + } + if (image_headers) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + image_headers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, image_headers, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientDownloadRequest::has_url() const { + return _internal_has_url(); +} +inline void ClientDownloadRequest::clear_url() { + url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientDownloadRequest::url() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.url) + return _internal_url(); +} +inline void ClientDownloadRequest::set_url(const std::string& value) { + _internal_set_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.url) +} +inline std::string* ClientDownloadRequest::mutable_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.url) + return _internal_mutable_url(); +} +inline const std::string& ClientDownloadRequest::_internal_url() const { + return url_.GetNoArena(); +} +inline void ClientDownloadRequest::_internal_set_url(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest::set_url(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.url) +} +inline void ClientDownloadRequest::set_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.url) +} +inline void ClientDownloadRequest::set_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.url) +} +inline std::string* ClientDownloadRequest::_internal_mutable_url() { + _has_bits_[0] |= 0x00000001u; + return url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadRequest::release_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.url) + if (!_internal_has_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest::set_allocated_url(std::string* url) { + if (url != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url); + // @@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 = (_has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || digests_ != nullptr); + return value; +} +inline bool ClientDownloadRequest::has_digests() const { + return _internal_has_digests(); +} +inline void ClientDownloadRequest::clear_digests() { + if (digests_ != nullptr) digests_->Clear(); + _has_bits_[0] &= ~0x00000010u; +} +inline const ::safe_browsing::ClientDownloadRequest_Digests& ClientDownloadRequest::_internal_digests() const { + const ::safe_browsing::ClientDownloadRequest_Digests* p = 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 ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest::release_digests() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.digests) + _has_bits_[0] &= ~0x00000010u; + ::safe_browsing::ClientDownloadRequest_Digests* temp = digests_; + digests_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest::_internal_mutable_digests() { + _has_bits_[0] |= 0x00000010u; + if (digests_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_Digests>(GetArenaNoVirtual()); + digests_ = p; + } + return digests_; +} +inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest::mutable_digests() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.digests) + return _internal_mutable_digests(); +} +inline void ClientDownloadRequest::set_allocated_digests(::safe_browsing::ClientDownloadRequest_Digests* digests) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete digests_; + } + if (digests) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + digests = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, digests, submessage_arena); + } + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + 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 = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool ClientDownloadRequest::has_length() const { + return _internal_has_length(); +} +inline void ClientDownloadRequest::clear_length() { + length_ = PROTOBUF_LONGLONG(0); + _has_bits_[0] &= ~0x00000100u; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ClientDownloadRequest::_internal_length() const { + return length_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ClientDownloadRequest::length() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.length) + return _internal_length(); +} +inline void ClientDownloadRequest::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int64 value) { + _has_bits_[0] |= 0x00000100u; + length_ = value; +} +inline void ClientDownloadRequest::set_length(::PROTOBUF_NAMESPACE_ID::int64 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 resources_.size(); +} +inline int ClientDownloadRequest::resources_size() const { + return _internal_resources_size(); +} +inline void ClientDownloadRequest::clear_resources() { + resources_.Clear(); +} +inline ::safe_browsing::ClientDownloadRequest_Resource* ClientDownloadRequest::mutable_resources(int index) { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.resources) + return 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 &resources_; +} +inline const ::safe_browsing::ClientDownloadRequest_Resource& ClientDownloadRequest::_internal_resources(int index) const { + return 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 resources_.Add(); +} +inline ::safe_browsing::ClientDownloadRequest_Resource* ClientDownloadRequest::add_resources() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.resources) + return _internal_add_resources(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource >& +ClientDownloadRequest::resources() const { + // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.resources) + return resources_; +} + +// optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5; +inline bool ClientDownloadRequest::_internal_has_signature() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || signature_ != nullptr); + return value; +} +inline bool ClientDownloadRequest::has_signature() const { + return _internal_has_signature(); +} +inline void ClientDownloadRequest::clear_signature() { + if (signature_ != nullptr) signature_->Clear(); + _has_bits_[0] &= ~0x00000020u; +} +inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientDownloadRequest::_internal_signature() const { + const ::safe_browsing::ClientDownloadRequest_SignatureInfo* p = 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 ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest::release_signature() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.signature) + _has_bits_[0] &= ~0x00000020u; + ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = signature_; + signature_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest::_internal_mutable_signature() { + _has_bits_[0] |= 0x00000020u; + if (signature_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_SignatureInfo>(GetArenaNoVirtual()); + signature_ = p; + } + return signature_; +} +inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest::mutable_signature() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.signature) + return _internal_mutable_signature(); +} +inline void ClientDownloadRequest::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete signature_; + } + if (signature) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + signature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, signature, submessage_arena); + } + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + 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 = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool ClientDownloadRequest::has_user_initiated() const { + return _internal_has_user_initiated(); +} +inline void ClientDownloadRequest::clear_user_initiated() { + user_initiated_ = false; + _has_bits_[0] &= ~0x00000800u; +} +inline bool ClientDownloadRequest::_internal_user_initiated() const { + return 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) { + _has_bits_[0] |= 0x00000800u; + 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 = (_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() { + file_basename_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest::set_file_basename(const std::string& value) { + _internal_set_file_basename(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.file_basename) +} +inline std::string* ClientDownloadRequest::mutable_file_basename() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.file_basename) + return _internal_mutable_file_basename(); +} +inline const std::string& ClientDownloadRequest::_internal_file_basename() const { + return file_basename_.GetNoArena(); +} +inline void ClientDownloadRequest::_internal_set_file_basename(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + file_basename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest::set_file_basename(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + file_basename_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.file_basename) +} +inline void ClientDownloadRequest::set_file_basename(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + file_basename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.file_basename) +} +inline void ClientDownloadRequest::set_file_basename(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + file_basename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.file_basename) +} +inline std::string* ClientDownloadRequest::_internal_mutable_file_basename() { + _has_bits_[0] |= 0x00000002u; + return file_basename_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadRequest::release_file_basename() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.file_basename) + if (!_internal_has_file_basename()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return file_basename_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest::set_allocated_file_basename(std::string* file_basename) { + if (file_basename != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + file_basename_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), file_basename); + // @@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 = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool ClientDownloadRequest::has_download_type() const { + return _internal_has_download_type(); +} +inline void ClientDownloadRequest::clear_download_type() { + download_type_ = 0; + _has_bits_[0] &= ~0x00000400u; +} +inline ::safe_browsing::ClientDownloadRequest_DownloadType ClientDownloadRequest::_internal_download_type() const { + return static_cast< ::safe_browsing::ClientDownloadRequest_DownloadType >(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)); + _has_bits_[0] |= 0x00000400u; + 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 = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ClientDownloadRequest::has_locale() const { + return _internal_has_locale(); +} +inline void ClientDownloadRequest::clear_locale() { + locale_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& ClientDownloadRequest::locale() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.locale) + return _internal_locale(); +} +inline void ClientDownloadRequest::set_locale(const std::string& value) { + _internal_set_locale(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.locale) +} +inline std::string* ClientDownloadRequest::mutable_locale() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.locale) + return _internal_mutable_locale(); +} +inline const std::string& ClientDownloadRequest::_internal_locale() const { + return locale_.GetNoArena(); +} +inline void ClientDownloadRequest::_internal_set_locale(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + locale_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest::set_locale(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + locale_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.locale) +} +inline void ClientDownloadRequest::set_locale(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + locale_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.locale) +} +inline void ClientDownloadRequest::set_locale(const char* value, size_t size) { + _has_bits_[0] |= 0x00000004u; + locale_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.locale) +} +inline std::string* ClientDownloadRequest::_internal_mutable_locale() { + _has_bits_[0] |= 0x00000004u; + return locale_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadRequest::release_locale() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.locale) + if (!_internal_has_locale()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + return locale_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest::set_allocated_locale(std::string* locale) { + if (locale != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + locale_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), locale); + // @@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 = (_has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || image_headers_ != nullptr); + return value; +} +inline bool ClientDownloadRequest::has_image_headers() const { + return _internal_has_image_headers(); +} +inline void ClientDownloadRequest::clear_image_headers() { + if (image_headers_ != nullptr) image_headers_->Clear(); + _has_bits_[0] &= ~0x00000040u; +} +inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientDownloadRequest::_internal_image_headers() const { + const ::safe_browsing::ClientDownloadRequest_ImageHeaders* p = 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 ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest::release_image_headers() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.image_headers) + _has_bits_[0] &= ~0x00000040u; + ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = image_headers_; + image_headers_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest::_internal_mutable_image_headers() { + _has_bits_[0] |= 0x00000040u; + if (image_headers_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_ImageHeaders>(GetArenaNoVirtual()); + image_headers_ = p; + } + return image_headers_; +} +inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest::mutable_image_headers() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.image_headers) + return _internal_mutable_image_headers(); +} +inline void ClientDownloadRequest::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete image_headers_; + } + if (image_headers) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + image_headers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, image_headers, submessage_arena); + } + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + 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 archived_binary_.size(); +} +inline int ClientDownloadRequest::archived_binary_size() const { + return _internal_archived_binary_size(); +} +inline void ClientDownloadRequest::clear_archived_binary() { + 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 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 &archived_binary_; +} +inline const ::safe_browsing::ClientDownloadRequest_ArchivedBinary& ClientDownloadRequest::_internal_archived_binary(int index) const { + return 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 archived_binary_.Add(); +} +inline ::safe_browsing::ClientDownloadRequest_ArchivedBinary* ClientDownloadRequest::add_archived_binary() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.archived_binary) + return _internal_add_archived_binary(); +} +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 archived_binary_; +} + +// optional .safe_browsing.ChromeUserPopulation population = 24; +inline bool ClientDownloadRequest::_internal_has_population() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || population_ != nullptr); + return value; +} +inline bool ClientDownloadRequest::has_population() const { + return _internal_has_population(); +} +inline void ClientDownloadRequest::clear_population() { + if (population_ != nullptr) population_->Clear(); + _has_bits_[0] &= ~0x00000080u; +} +inline const ::safe_browsing::ChromeUserPopulation& ClientDownloadRequest::_internal_population() const { + const ::safe_browsing::ChromeUserPopulation* p = 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 ::safe_browsing::ChromeUserPopulation* ClientDownloadRequest::release_population() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadRequest.population) + _has_bits_[0] &= ~0x00000080u; + ::safe_browsing::ChromeUserPopulation* temp = population_; + population_ = nullptr; + return temp; +} +inline ::safe_browsing::ChromeUserPopulation* ClientDownloadRequest::_internal_mutable_population() { + _has_bits_[0] |= 0x00000080u; + if (population_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ChromeUserPopulation>(GetArenaNoVirtual()); + population_ = p; + } + return population_; +} +inline ::safe_browsing::ChromeUserPopulation* ClientDownloadRequest::mutable_population() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.population) + return _internal_mutable_population(); +} +inline void ClientDownloadRequest::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete population_; + } + if (population) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + population = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, population, submessage_arena); + } + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + 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 = (_has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool ClientDownloadRequest::has_archive_valid() const { + return _internal_has_archive_valid(); +} +inline void ClientDownloadRequest::clear_archive_valid() { + archive_valid_ = false; + _has_bits_[0] &= ~0x00001000u; +} +inline bool ClientDownloadRequest::_internal_archive_valid() const { + return 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) { + _has_bits_[0] |= 0x00001000u; + 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 = (_has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool ClientDownloadRequest::has_skipped_url_whitelist() const { + return _internal_has_skipped_url_whitelist(); +} +inline void ClientDownloadRequest::clear_skipped_url_whitelist() { + skipped_url_whitelist_ = false; + _has_bits_[0] &= ~0x00002000u; +} +inline bool ClientDownloadRequest::_internal_skipped_url_whitelist() const { + return 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) { + _has_bits_[0] |= 0x00002000u; + 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 = (_has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool ClientDownloadRequest::has_skipped_certificate_whitelist() const { + return _internal_has_skipped_certificate_whitelist(); +} +inline void ClientDownloadRequest::clear_skipped_certificate_whitelist() { + skipped_certificate_whitelist_ = false; + _has_bits_[0] &= ~0x00004000u; +} +inline bool ClientDownloadRequest::_internal_skipped_certificate_whitelist() const { + return 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) { + _has_bits_[0] |= 0x00004000u; + 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 alternate_extensions_.size(); +} +inline int ClientDownloadRequest::alternate_extensions_size() const { + return _internal_alternate_extensions_size(); +} +inline void ClientDownloadRequest::clear_alternate_extensions() { + alternate_extensions_.Clear(); +} +inline std::string* ClientDownloadRequest::add_alternate_extensions() { + // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientDownloadRequest.alternate_extensions) + return _internal_add_alternate_extensions(); +} +inline const std::string& ClientDownloadRequest::_internal_alternate_extensions(int index) const { + return 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 alternate_extensions_.Mutable(index); +} +inline void ClientDownloadRequest::set_alternate_extensions(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.alternate_extensions) + alternate_extensions_.Mutable(index)->assign(value); +} +inline void ClientDownloadRequest::set_alternate_extensions(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.alternate_extensions) + alternate_extensions_.Mutable(index)->assign(std::move(value)); +} +inline void ClientDownloadRequest::set_alternate_extensions(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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) { + 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 alternate_extensions_.Add(); +} +inline void ClientDownloadRequest::add_alternate_extensions(const std::string& value) { + alternate_extensions_.Add()->assign(value); + // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.alternate_extensions) +} +inline void ClientDownloadRequest::add_alternate_extensions(std::string&& value) { + 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); + 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) { + 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 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 &alternate_extensions_; +} + +// repeated .safe_browsing.ReferrerChainEntry referrer_chain = 36; +inline int ClientDownloadRequest::_internal_referrer_chain_size() const { + return referrer_chain_.size(); +} +inline int ClientDownloadRequest::referrer_chain_size() const { + return _internal_referrer_chain_size(); +} +inline void ClientDownloadRequest::clear_referrer_chain() { + referrer_chain_.Clear(); +} +inline ::safe_browsing::ReferrerChainEntry* ClientDownloadRequest::mutable_referrer_chain(int index) { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.referrer_chain) + return 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 &referrer_chain_; +} +inline const ::safe_browsing::ReferrerChainEntry& ClientDownloadRequest::_internal_referrer_chain(int index) const { + return 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 referrer_chain_.Add(); +} +inline ::safe_browsing::ReferrerChainEntry* ClientDownloadRequest::add_referrer_chain() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.referrer_chain) + return _internal_add_referrer_chain(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ReferrerChainEntry >& +ClientDownloadRequest::referrer_chain() const { + // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.referrer_chain) + return 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 = (_has_bits_[0] & 0x00000200u) != 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() { + deprecated_download_attribution_finch_enabled_ = false; + _has_bits_[0] &= ~0x00000200u; +} +inline bool ClientDownloadRequest::_internal_deprecated_download_attribution_finch_enabled() const { + return 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) { + _has_bits_[0] |= 0x00000200u; + 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 = (_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() { + udif_code_signature_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadRequest::set_udif_code_signature(const std::string& value) { + _internal_set_udif_code_signature(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.udif_code_signature) +} +inline std::string* ClientDownloadRequest::mutable_udif_code_signature() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.udif_code_signature) + return _internal_mutable_udif_code_signature(); +} +inline const std::string& ClientDownloadRequest::_internal_udif_code_signature() const { + return udif_code_signature_.GetNoArena(); +} +inline void ClientDownloadRequest::_internal_set_udif_code_signature(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + udif_code_signature_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadRequest::set_udif_code_signature(std::string&& value) { + _has_bits_[0] |= 0x00000008u; + udif_code_signature_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadRequest.udif_code_signature) +} +inline void ClientDownloadRequest::set_udif_code_signature(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000008u; + udif_code_signature_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.udif_code_signature) +} +inline void ClientDownloadRequest::set_udif_code_signature(const void* value, size_t size) { + _has_bits_[0] |= 0x00000008u; + udif_code_signature_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.udif_code_signature) +} +inline std::string* ClientDownloadRequest::_internal_mutable_udif_code_signature() { + _has_bits_[0] |= 0x00000008u; + return udif_code_signature_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000008u; + return udif_code_signature_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadRequest::set_allocated_udif_code_signature(std::string* udif_code_signature) { + if (udif_code_signature != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + udif_code_signature_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), udif_code_signature); + // @@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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ReferrerChainEntry_ServerRedirect::has_url() const { + return _internal_has_url(); +} +inline void ReferrerChainEntry_ServerRedirect::clear_url() { + url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ReferrerChainEntry_ServerRedirect::set_url(const std::string& value) { + _internal_set_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.ServerRedirect.url) +} +inline std::string* ReferrerChainEntry_ServerRedirect::mutable_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ReferrerChainEntry.ServerRedirect.url) + return _internal_mutable_url(); +} +inline const std::string& ReferrerChainEntry_ServerRedirect::_internal_url() const { + return url_.GetNoArena(); +} +inline void ReferrerChainEntry_ServerRedirect::_internal_set_url(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ReferrerChainEntry_ServerRedirect::set_url(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ReferrerChainEntry.ServerRedirect.url) +} +inline void ReferrerChainEntry_ServerRedirect::set_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ReferrerChainEntry.ServerRedirect.url) +} +inline void ReferrerChainEntry_ServerRedirect::set_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ReferrerChainEntry.ServerRedirect.url) +} +inline std::string* ReferrerChainEntry_ServerRedirect::_internal_mutable_url() { + _has_bits_[0] |= 0x00000001u; + return url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ReferrerChainEntry_ServerRedirect::release_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ReferrerChainEntry.ServerRedirect.url) + if (!_internal_has_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ReferrerChainEntry_ServerRedirect::set_allocated_url(std::string* url) { + if (url != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url); + // @@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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ReferrerChainEntry::has_url() const { + return _internal_has_url(); +} +inline void ReferrerChainEntry::clear_url() { + url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ReferrerChainEntry::url() const { + // @@protoc_insertion_point(field_get:safe_browsing.ReferrerChainEntry.url) + return _internal_url(); +} +inline void ReferrerChainEntry::set_url(const std::string& value) { + _internal_set_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.url) +} +inline std::string* ReferrerChainEntry::mutable_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ReferrerChainEntry.url) + return _internal_mutable_url(); +} +inline const std::string& ReferrerChainEntry::_internal_url() const { + return url_.GetNoArena(); +} +inline void ReferrerChainEntry::_internal_set_url(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ReferrerChainEntry::set_url(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ReferrerChainEntry.url) +} +inline void ReferrerChainEntry::set_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ReferrerChainEntry.url) +} +inline void ReferrerChainEntry::set_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ReferrerChainEntry.url) +} +inline std::string* ReferrerChainEntry::_internal_mutable_url() { + _has_bits_[0] |= 0x00000001u; + return url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ReferrerChainEntry::release_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ReferrerChainEntry.url) + if (!_internal_has_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ReferrerChainEntry::set_allocated_url(std::string* url) { + if (url != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url); + // @@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 = (_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() { + main_frame_url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ReferrerChainEntry::set_main_frame_url(const std::string& value) { + _internal_set_main_frame_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.main_frame_url) +} +inline std::string* ReferrerChainEntry::mutable_main_frame_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ReferrerChainEntry.main_frame_url) + return _internal_mutable_main_frame_url(); +} +inline const std::string& ReferrerChainEntry::_internal_main_frame_url() const { + return main_frame_url_.GetNoArena(); +} +inline void ReferrerChainEntry::_internal_set_main_frame_url(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + main_frame_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ReferrerChainEntry::set_main_frame_url(std::string&& value) { + _has_bits_[0] |= 0x00000008u; + main_frame_url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ReferrerChainEntry.main_frame_url) +} +inline void ReferrerChainEntry::set_main_frame_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000008u; + main_frame_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ReferrerChainEntry.main_frame_url) +} +inline void ReferrerChainEntry::set_main_frame_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000008u; + main_frame_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ReferrerChainEntry.main_frame_url) +} +inline std::string* ReferrerChainEntry::_internal_mutable_main_frame_url() { + _has_bits_[0] |= 0x00000008u; + return main_frame_url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000008u; + return main_frame_url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ReferrerChainEntry::set_allocated_main_frame_url(std::string* main_frame_url) { + if (main_frame_url != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + main_frame_url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), main_frame_url); + // @@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 = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ReferrerChainEntry::has_type() const { + return _internal_has_type(); +} +inline void ReferrerChainEntry::clear_type() { + type_ = 4; + _has_bits_[0] &= ~0x00000040u; +} +inline ::safe_browsing::ReferrerChainEntry_URLType ReferrerChainEntry::_internal_type() const { + return static_cast< ::safe_browsing::ReferrerChainEntry_URLType >(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)); + _has_bits_[0] |= 0x00000040u; + 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 ip_addresses_.size(); +} +inline int ReferrerChainEntry::ip_addresses_size() const { + return _internal_ip_addresses_size(); +} +inline void ReferrerChainEntry::clear_ip_addresses() { + ip_addresses_.Clear(); +} +inline std::string* ReferrerChainEntry::add_ip_addresses() { + // @@protoc_insertion_point(field_add_mutable:safe_browsing.ReferrerChainEntry.ip_addresses) + return _internal_add_ip_addresses(); +} +inline const std::string& ReferrerChainEntry::_internal_ip_addresses(int index) const { + return 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 ip_addresses_.Mutable(index); +} +inline void ReferrerChainEntry::set_ip_addresses(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.ip_addresses) + ip_addresses_.Mutable(index)->assign(value); +} +inline void ReferrerChainEntry::set_ip_addresses(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.ip_addresses) + ip_addresses_.Mutable(index)->assign(std::move(value)); +} +inline void ReferrerChainEntry::set_ip_addresses(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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) { + 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 ip_addresses_.Add(); +} +inline void ReferrerChainEntry::add_ip_addresses(const std::string& value) { + ip_addresses_.Add()->assign(value); + // @@protoc_insertion_point(field_add:safe_browsing.ReferrerChainEntry.ip_addresses) +} +inline void ReferrerChainEntry::add_ip_addresses(std::string&& value) { + 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); + 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) { + 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 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 &ip_addresses_; +} + +// optional string referrer_url = 4; +inline bool ReferrerChainEntry::_internal_has_referrer_url() const { + bool value = (_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() { + referrer_url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ReferrerChainEntry::set_referrer_url(const std::string& value) { + _internal_set_referrer_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.referrer_url) +} +inline std::string* ReferrerChainEntry::mutable_referrer_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ReferrerChainEntry.referrer_url) + return _internal_mutable_referrer_url(); +} +inline const std::string& ReferrerChainEntry::_internal_referrer_url() const { + return referrer_url_.GetNoArena(); +} +inline void ReferrerChainEntry::_internal_set_referrer_url(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + referrer_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ReferrerChainEntry::set_referrer_url(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + referrer_url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ReferrerChainEntry.referrer_url) +} +inline void ReferrerChainEntry::set_referrer_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + referrer_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ReferrerChainEntry.referrer_url) +} +inline void ReferrerChainEntry::set_referrer_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + referrer_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ReferrerChainEntry.referrer_url) +} +inline std::string* ReferrerChainEntry::_internal_mutable_referrer_url() { + _has_bits_[0] |= 0x00000002u; + return referrer_url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ReferrerChainEntry::release_referrer_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ReferrerChainEntry.referrer_url) + if (!_internal_has_referrer_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return referrer_url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ReferrerChainEntry::set_allocated_referrer_url(std::string* referrer_url) { + if (referrer_url != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + referrer_url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), referrer_url); + // @@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 = (_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() { + referrer_main_frame_url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ReferrerChainEntry::set_referrer_main_frame_url(const std::string& value) { + _internal_set_referrer_main_frame_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ReferrerChainEntry.referrer_main_frame_url) +} +inline std::string* ReferrerChainEntry::mutable_referrer_main_frame_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ReferrerChainEntry.referrer_main_frame_url) + return _internal_mutable_referrer_main_frame_url(); +} +inline const std::string& ReferrerChainEntry::_internal_referrer_main_frame_url() const { + return referrer_main_frame_url_.GetNoArena(); +} +inline void ReferrerChainEntry::_internal_set_referrer_main_frame_url(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + referrer_main_frame_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ReferrerChainEntry::set_referrer_main_frame_url(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + referrer_main_frame_url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ReferrerChainEntry.referrer_main_frame_url) +} +inline void ReferrerChainEntry::set_referrer_main_frame_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + referrer_main_frame_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ReferrerChainEntry.referrer_main_frame_url) +} +inline void ReferrerChainEntry::set_referrer_main_frame_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000004u; + referrer_main_frame_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ReferrerChainEntry.referrer_main_frame_url) +} +inline std::string* ReferrerChainEntry::_internal_mutable_referrer_main_frame_url() { + _has_bits_[0] |= 0x00000004u; + return referrer_main_frame_url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000004u; + return referrer_main_frame_url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ReferrerChainEntry::set_allocated_referrer_main_frame_url(std::string* referrer_main_frame_url) { + if (referrer_main_frame_url != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + referrer_main_frame_url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), referrer_main_frame_url); + // @@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 = (_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() { + is_retargeting_ = false; + _has_bits_[0] &= ~0x00000020u; +} +inline bool ReferrerChainEntry::_internal_is_retargeting() const { + return 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) { + _has_bits_[0] |= 0x00000020u; + 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 = (_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() { + navigation_time_msec_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline double ReferrerChainEntry::_internal_navigation_time_msec() const { + return 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) { + _has_bits_[0] |= 0x00000010u; + 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 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() { + 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 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 &server_redirect_chain_; +} +inline const ::safe_browsing::ReferrerChainEntry_ServerRedirect& ReferrerChainEntry::_internal_server_redirect_chain(int index) const { + return 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 server_redirect_chain_.Add(); +} +inline ::safe_browsing::ReferrerChainEntry_ServerRedirect* ReferrerChainEntry::add_server_redirect_chain() { + // @@protoc_insertion_point(field_add:safe_browsing.ReferrerChainEntry.server_redirect_chain) + return _internal_add_server_redirect_chain(); +} +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 server_redirect_chain_; +} + +// ------------------------------------------------------------------- + +// ClientDownloadResponse_MoreInfo + +// optional string description = 1; +inline bool ClientDownloadResponse_MoreInfo::_internal_has_description() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientDownloadResponse_MoreInfo::has_description() const { + return _internal_has_description(); +} +inline void ClientDownloadResponse_MoreInfo::clear_description() { + description_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadResponse_MoreInfo::set_description(const std::string& value) { + _internal_set_description(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadResponse.MoreInfo.description) +} +inline std::string* ClientDownloadResponse_MoreInfo::mutable_description() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadResponse.MoreInfo.description) + return _internal_mutable_description(); +} +inline const std::string& ClientDownloadResponse_MoreInfo::_internal_description() const { + return description_.GetNoArena(); +} +inline void ClientDownloadResponse_MoreInfo::_internal_set_description(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadResponse_MoreInfo::set_description(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + description_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadResponse.MoreInfo.description) +} +inline void ClientDownloadResponse_MoreInfo::set_description(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadResponse.MoreInfo.description) +} +inline void ClientDownloadResponse_MoreInfo::set_description(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadResponse.MoreInfo.description) +} +inline std::string* ClientDownloadResponse_MoreInfo::_internal_mutable_description() { + _has_bits_[0] |= 0x00000001u; + return description_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadResponse_MoreInfo::release_description() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadResponse.MoreInfo.description) + if (!_internal_has_description()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return description_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadResponse_MoreInfo::set_allocated_description(std::string* description) { + if (description != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + description_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientDownloadResponse_MoreInfo::has_url() const { + return _internal_has_url(); +} +inline void ClientDownloadResponse_MoreInfo::clear_url() { + url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadResponse_MoreInfo::set_url(const std::string& value) { + _internal_set_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadResponse.MoreInfo.url) +} +inline std::string* ClientDownloadResponse_MoreInfo::mutable_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadResponse.MoreInfo.url) + return _internal_mutable_url(); +} +inline const std::string& ClientDownloadResponse_MoreInfo::_internal_url() const { + return url_.GetNoArena(); +} +inline void ClientDownloadResponse_MoreInfo::_internal_set_url(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadResponse_MoreInfo::set_url(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadResponse.MoreInfo.url) +} +inline void ClientDownloadResponse_MoreInfo::set_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadResponse.MoreInfo.url) +} +inline void ClientDownloadResponse_MoreInfo::set_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadResponse.MoreInfo.url) +} +inline std::string* ClientDownloadResponse_MoreInfo::_internal_mutable_url() { + _has_bits_[0] |= 0x00000002u; + return url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadResponse_MoreInfo::release_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadResponse.MoreInfo.url) + if (!_internal_has_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadResponse_MoreInfo::set_allocated_url(std::string* url) { + if (url != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url); + // @@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 = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ClientDownloadResponse::has_verdict() const { + return _internal_has_verdict(); +} +inline void ClientDownloadResponse::clear_verdict() { + verdict_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline ::safe_browsing::ClientDownloadResponse_Verdict ClientDownloadResponse::_internal_verdict() const { + return static_cast< ::safe_browsing::ClientDownloadResponse_Verdict >(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)); + _has_bits_[0] |= 0x00000004u; + 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 = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || more_info_ != nullptr); + return value; +} +inline bool ClientDownloadResponse::has_more_info() const { + return _internal_has_more_info(); +} +inline void ClientDownloadResponse::clear_more_info() { + if (more_info_ != nullptr) more_info_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::safe_browsing::ClientDownloadResponse_MoreInfo& ClientDownloadResponse::_internal_more_info() const { + const ::safe_browsing::ClientDownloadResponse_MoreInfo* p = 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 ::safe_browsing::ClientDownloadResponse_MoreInfo* ClientDownloadResponse::release_more_info() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadResponse.more_info) + _has_bits_[0] &= ~0x00000002u; + ::safe_browsing::ClientDownloadResponse_MoreInfo* temp = more_info_; + more_info_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadResponse_MoreInfo* ClientDownloadResponse::_internal_mutable_more_info() { + _has_bits_[0] |= 0x00000002u; + if (more_info_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadResponse_MoreInfo>(GetArenaNoVirtual()); + more_info_ = p; + } + return more_info_; +} +inline ::safe_browsing::ClientDownloadResponse_MoreInfo* ClientDownloadResponse::mutable_more_info() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadResponse.more_info) + return _internal_mutable_more_info(); +} +inline void ClientDownloadResponse::set_allocated_more_info(::safe_browsing::ClientDownloadResponse_MoreInfo* more_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete more_info_; + } + if (more_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + more_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, more_info, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientDownloadResponse::has_token() const { + return _internal_has_token(); +} +inline void ClientDownloadResponse::clear_token() { + token_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientDownloadResponse::token() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadResponse.token) + return _internal_token(); +} +inline void ClientDownloadResponse::set_token(const std::string& value) { + _internal_set_token(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadResponse.token) +} +inline std::string* ClientDownloadResponse::mutable_token() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadResponse.token) + return _internal_mutable_token(); +} +inline const std::string& ClientDownloadResponse::_internal_token() const { + return token_.GetNoArena(); +} +inline void ClientDownloadResponse::_internal_set_token(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadResponse::set_token(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + token_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadResponse.token) +} +inline void ClientDownloadResponse::set_token(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadResponse.token) +} +inline void ClientDownloadResponse::set_token(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadResponse.token) +} +inline std::string* ClientDownloadResponse::_internal_mutable_token() { + _has_bits_[0] |= 0x00000001u; + return token_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadResponse::release_token() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadResponse.token) + if (!_internal_has_token()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return token_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadResponse::set_allocated_token(std::string* token) { + if (token != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + token_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), token); + // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadResponse.token) +} + +// optional bool upload = 5; +inline bool ClientDownloadResponse::_internal_has_upload() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ClientDownloadResponse::has_upload() const { + return _internal_has_upload(); +} +inline void ClientDownloadResponse::clear_upload() { + upload_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool ClientDownloadResponse::_internal_upload() const { + return 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) { + _has_bits_[0] |= 0x00000008u; + 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientDownloadReport_UserInformation::has_email() const { + return _internal_has_email(); +} +inline void ClientDownloadReport_UserInformation::clear_email() { + email_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientDownloadReport_UserInformation::set_email(const std::string& value) { + _internal_set_email(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadReport.UserInformation.email) +} +inline std::string* ClientDownloadReport_UserInformation::mutable_email() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.UserInformation.email) + return _internal_mutable_email(); +} +inline const std::string& ClientDownloadReport_UserInformation::_internal_email() const { + return email_.GetNoArena(); +} +inline void ClientDownloadReport_UserInformation::_internal_set_email(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + email_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadReport_UserInformation::set_email(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + email_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadReport.UserInformation.email) +} +inline void ClientDownloadReport_UserInformation::set_email(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + email_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadReport.UserInformation.email) +} +inline void ClientDownloadReport_UserInformation::set_email(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + email_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadReport.UserInformation.email) +} +inline std::string* ClientDownloadReport_UserInformation::_internal_mutable_email() { + _has_bits_[0] |= 0x00000001u; + return email_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadReport_UserInformation::release_email() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadReport.UserInformation.email) + if (!_internal_has_email()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return email_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadReport_UserInformation::set_allocated_email(std::string* email) { + if (email != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + email_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), email); + // @@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 = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ClientDownloadReport::has_reason() const { + return _internal_has_reason(); +} +inline void ClientDownloadReport::clear_reason() { + reason_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline ::safe_browsing::ClientDownloadReport_Reason ClientDownloadReport::_internal_reason() const { + return static_cast< ::safe_browsing::ClientDownloadReport_Reason >(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)); + _has_bits_[0] |= 0x00000010u; + 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 = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || download_request_ != nullptr); + return value; +} +inline bool ClientDownloadReport::has_download_request() const { + return _internal_has_download_request(); +} +inline void ClientDownloadReport::clear_download_request() { + if (download_request_ != nullptr) download_request_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::safe_browsing::ClientDownloadRequest& ClientDownloadReport::_internal_download_request() const { + const ::safe_browsing::ClientDownloadRequest* p = 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 ::safe_browsing::ClientDownloadRequest* ClientDownloadReport::release_download_request() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadReport.download_request) + _has_bits_[0] &= ~0x00000002u; + ::safe_browsing::ClientDownloadRequest* temp = download_request_; + download_request_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest* ClientDownloadReport::_internal_mutable_download_request() { + _has_bits_[0] |= 0x00000002u; + if (download_request_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest>(GetArenaNoVirtual()); + download_request_ = p; + } + return download_request_; +} +inline ::safe_browsing::ClientDownloadRequest* ClientDownloadReport::mutable_download_request() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.download_request) + return _internal_mutable_download_request(); +} +inline void ClientDownloadReport::set_allocated_download_request(::safe_browsing::ClientDownloadRequest* download_request) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete download_request_; + } + if (download_request) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + download_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, download_request, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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 = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || user_information_ != nullptr); + return value; +} +inline bool ClientDownloadReport::has_user_information() const { + return _internal_has_user_information(); +} +inline void ClientDownloadReport::clear_user_information() { + if (user_information_ != nullptr) user_information_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::safe_browsing::ClientDownloadReport_UserInformation& ClientDownloadReport::_internal_user_information() const { + const ::safe_browsing::ClientDownloadReport_UserInformation* p = 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 ::safe_browsing::ClientDownloadReport_UserInformation* ClientDownloadReport::release_user_information() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadReport.user_information) + _has_bits_[0] &= ~0x00000004u; + ::safe_browsing::ClientDownloadReport_UserInformation* temp = user_information_; + user_information_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadReport_UserInformation* ClientDownloadReport::_internal_mutable_user_information() { + _has_bits_[0] |= 0x00000004u; + if (user_information_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadReport_UserInformation>(GetArenaNoVirtual()); + user_information_ = p; + } + return user_information_; +} +inline ::safe_browsing::ClientDownloadReport_UserInformation* ClientDownloadReport::mutable_user_information() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.user_information) + return _internal_mutable_user_information(); +} +inline void ClientDownloadReport::set_allocated_user_information(::safe_browsing::ClientDownloadReport_UserInformation* user_information) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete user_information_; + } + if (user_information) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + user_information = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, user_information, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientDownloadReport::has_comment() const { + return _internal_has_comment(); +} +inline void ClientDownloadReport::clear_comment() { + comment_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientDownloadReport::comment() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadReport.comment) + return _internal_comment(); +} +inline void ClientDownloadReport::set_comment(const std::string& value) { + _internal_set_comment(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadReport.comment) +} +inline std::string* ClientDownloadReport::mutable_comment() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.comment) + return _internal_mutable_comment(); +} +inline const std::string& ClientDownloadReport::_internal_comment() const { + return comment_.GetNoArena(); +} +inline void ClientDownloadReport::_internal_set_comment(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + comment_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientDownloadReport::set_comment(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + comment_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientDownloadReport.comment) +} +inline void ClientDownloadReport::set_comment(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + comment_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadReport.comment) +} +inline void ClientDownloadReport::set_comment(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + comment_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadReport.comment) +} +inline std::string* ClientDownloadReport::_internal_mutable_comment() { + _has_bits_[0] |= 0x00000001u; + return comment_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientDownloadReport::release_comment() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadReport.comment) + if (!_internal_has_comment()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return comment_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientDownloadReport::set_allocated_comment(std::string* comment) { + if (comment != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + comment_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), comment); + // @@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 = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || download_response_ != nullptr); + return value; +} +inline bool ClientDownloadReport::has_download_response() const { + return _internal_has_download_response(); +} +inline void ClientDownloadReport::clear_download_response() { + if (download_response_ != nullptr) download_response_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::safe_browsing::ClientDownloadResponse& ClientDownloadReport::_internal_download_response() const { + const ::safe_browsing::ClientDownloadResponse* p = 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 ::safe_browsing::ClientDownloadResponse* ClientDownloadReport::release_download_response() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientDownloadReport.download_response) + _has_bits_[0] &= ~0x00000008u; + ::safe_browsing::ClientDownloadResponse* temp = download_response_; + download_response_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadResponse* ClientDownloadReport::_internal_mutable_download_response() { + _has_bits_[0] |= 0x00000008u; + if (download_response_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadResponse>(GetArenaNoVirtual()); + download_response_ = p; + } + return download_response_; +} +inline ::safe_browsing::ClientDownloadResponse* ClientDownloadReport::mutable_download_response() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.download_response) + return _internal_mutable_download_response(); +} +inline void ClientDownloadReport::set_allocated_download_response(::safe_browsing::ClientDownloadResponse* download_response) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete download_response_; + } + if (download_response) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + download_response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, download_response, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + 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 = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientUploadResponse::has_status() const { + return _internal_has_status(); +} +inline void ClientUploadResponse::clear_status() { + status_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::safe_browsing::ClientUploadResponse_UploadStatus ClientUploadResponse::_internal_status() const { + return static_cast< ::safe_browsing::ClientUploadResponse_UploadStatus >(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)); + _has_bits_[0] |= 0x00000002u; + 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientUploadResponse::has_permalink() const { + return _internal_has_permalink(); +} +inline void ClientUploadResponse::clear_permalink() { + permalink_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientUploadResponse::permalink() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientUploadResponse.permalink) + return _internal_permalink(); +} +inline void ClientUploadResponse::set_permalink(const std::string& value) { + _internal_set_permalink(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientUploadResponse.permalink) +} +inline std::string* ClientUploadResponse::mutable_permalink() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientUploadResponse.permalink) + return _internal_mutable_permalink(); +} +inline const std::string& ClientUploadResponse::_internal_permalink() const { + return permalink_.GetNoArena(); +} +inline void ClientUploadResponse::_internal_set_permalink(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + permalink_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientUploadResponse::set_permalink(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + permalink_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientUploadResponse.permalink) +} +inline void ClientUploadResponse::set_permalink(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + permalink_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientUploadResponse.permalink) +} +inline void ClientUploadResponse::set_permalink(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + permalink_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientUploadResponse.permalink) +} +inline std::string* ClientUploadResponse::_internal_mutable_permalink() { + _has_bits_[0] |= 0x00000001u; + return permalink_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientUploadResponse::release_permalink() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientUploadResponse.permalink) + if (!_internal_has_permalink()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return permalink_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientUploadResponse::set_allocated_permalink(std::string* permalink) { + if (permalink != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + permalink_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), permalink); + // @@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 = (_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() { + path_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_path(const std::string& value) { + _internal_set_path(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path) +} +inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::mutable_path() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path) + return _internal_mutable_path(); +} +inline const std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_path() const { + return path_.GetNoArena(); +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_set_path(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_path(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + path_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path) +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_path(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path) +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_path(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path) +} +inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_mutable_path() { + _has_bits_[0] |= 0x00000001u; + return path_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return path_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_allocated_path(std::string* path) { + if (path != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + path_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), path); + // @@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 = (_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() { + atomic_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_atomic_value(const std::string& value) { + _internal_set_atomic_value(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value) +} +inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::mutable_atomic_value() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value) + return _internal_mutable_atomic_value(); +} +inline const std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_atomic_value() const { + return atomic_value_.GetNoArena(); +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_set_atomic_value(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + atomic_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_atomic_value(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + atomic_value_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value) +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_atomic_value(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + atomic_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value) +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_atomic_value(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + atomic_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value) +} +inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_mutable_atomic_value() { + _has_bits_[0] |= 0x00000002u; + return atomic_value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return atomic_value_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_allocated_atomic_value(std::string* atomic_value) { + if (atomic_value != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + atomic_value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), atomic_value); + // @@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 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() { + split_key_.Clear(); +} +inline std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::add_split_key() { + // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key) + return _internal_add_split_key(); +} +inline const std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_split_key(int index) const { + return 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 split_key_.Mutable(index); +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_split_key(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key) + split_key_.Mutable(index)->assign(value); +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_split_key(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.split_key) + split_key_.Mutable(index)->assign(std::move(value)); +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_split_key(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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) { + 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 split_key_.Add(); +} +inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::add_split_key(const std::string& value) { + 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) { + 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); + 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) { + 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 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 &split_key_; +} + +// optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.ValueState value_state = 4; +inline bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident::_internal_has_value_state() const { + bool value = (_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() { + value_state_ = 0; + _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 >(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)); + _has_bits_[0] |= 0x00000004u; + 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 = (_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() { + relative_path_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_relative_path(const std::string& value) { + _internal_set_relative_path(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.relative_path) +} +inline std::string* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::mutable_relative_path() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.relative_path) + return _internal_mutable_relative_path(); +} +inline const std::string& ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_relative_path() const { + return relative_path_.GetNoArena(); +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_set_relative_path(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + relative_path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_relative_path(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + relative_path_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.relative_path) +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_relative_path(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + relative_path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.relative_path) +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_relative_path(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + relative_path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.relative_path) +} +inline std::string* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_mutable_relative_path() { + _has_bits_[0] |= 0x00000001u; + return relative_path_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return relative_path_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_allocated_relative_path(std::string* relative_path) { + if (relative_path != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + relative_path_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), relative_path); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || 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 (signature_ != nullptr) signature_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_signature() const { + const ::safe_browsing::ClientDownloadRequest_SignatureInfo* p = 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 ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::release_signature() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.signature) + _has_bits_[0] &= ~0x00000002u; + ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = signature_; + signature_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_mutable_signature() { + _has_bits_[0] |= 0x00000002u; + if (signature_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_SignatureInfo>(GetArenaNoVirtual()); + signature_ = p; + } + return signature_; +} +inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::mutable_signature() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.signature) + return _internal_mutable_signature(); +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete signature_; + } + if (signature) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + signature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, signature, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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 = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || 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 (image_headers_ != nullptr) image_headers_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_image_headers() const { + const ::safe_browsing::ClientDownloadRequest_ImageHeaders* p = 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 ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::release_image_headers() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.image_headers) + _has_bits_[0] &= ~0x00000004u; + ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = image_headers_; + image_headers_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::_internal_mutable_image_headers() { + _has_bits_[0] |= 0x00000004u; + if (image_headers_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_ImageHeaders>(GetArenaNoVirtual()); + image_headers_ = p; + } + return image_headers_; +} +inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::mutable_image_headers() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.image_headers) + return _internal_mutable_image_headers(); +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete image_headers_; + } + if (image_headers) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + image_headers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, image_headers, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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 = (_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() { + file_basename_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_file_basename(const std::string& value) { + _internal_set_file_basename(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.file_basename) +} +inline std::string* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::mutable_file_basename() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.file_basename) + return _internal_mutable_file_basename(); +} +inline const std::string& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_file_basename() const { + return file_basename_.GetNoArena(); +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_set_file_basename(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + file_basename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_file_basename(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + file_basename_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.file_basename) +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_file_basename(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + file_basename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.file_basename) +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_file_basename(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + file_basename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.file_basename) +} +inline std::string* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_mutable_file_basename() { + _has_bits_[0] |= 0x00000001u; + return file_basename_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return file_basename_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_allocated_file_basename(std::string* file_basename) { + if (file_basename != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + file_basename_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), file_basename); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || signature_ != nullptr); + return value; +} +inline bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident::has_signature() const { + return _internal_has_signature(); +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_signature() { + if (signature_ != nullptr) signature_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_signature() const { + const ::safe_browsing::ClientDownloadRequest_SignatureInfo* p = 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 ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::release_signature() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.signature) + _has_bits_[0] &= ~0x00000002u; + ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = signature_; + signature_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_mutable_signature() { + _has_bits_[0] |= 0x00000002u; + if (signature_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_SignatureInfo>(GetArenaNoVirtual()); + signature_ = p; + } + return signature_; +} +inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::mutable_signature() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.signature) + return _internal_mutable_signature(); +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete signature_; + } + if (signature) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + signature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, signature, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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 = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || 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 (image_headers_ != nullptr) image_headers_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_image_headers() const { + const ::safe_browsing::ClientDownloadRequest_ImageHeaders* p = 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 ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::release_image_headers() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.image_headers) + _has_bits_[0] &= ~0x00000004u; + ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = image_headers_; + image_headers_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_mutable_image_headers() { + _has_bits_[0] |= 0x00000004u; + if (image_headers_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_ImageHeaders>(GetArenaNoVirtual()); + image_headers_ = p; + } + return image_headers_; +} +inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::mutable_image_headers() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.image_headers) + return _internal_mutable_image_headers(); +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete image_headers_; + } + if (image_headers) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + image_headers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, image_headers, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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 = (_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() { + sec_error_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_sec_error() const { + return sec_error_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000008u; + sec_error_ = value; +} +inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_sec_error(::PROTOBUF_NAMESPACE_ID::int32 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 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() { + 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 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 &contained_file_; +} +inline const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::_internal_contained_file(int index) const { + return 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 contained_file_.Add(); +} +inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::add_contained_file() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.contained_file) + return _internal_add_contained_file(); +} +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 contained_file_; +} + +// ------------------------------------------------------------------- + +// ClientIncidentReport_IncidentData_ResourceRequestIncident + +// optional bytes digest = 1; +inline bool ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_has_digest() const { + bool value = (_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() { + digest_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_digest(const std::string& value) { + _internal_set_digest(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest) +} +inline std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::mutable_digest() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest) + return _internal_mutable_digest(); +} +inline const std::string& ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_digest() const { + return digest_.GetNoArena(); +} +inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_set_digest(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + digest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_digest(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + digest_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest) +} +inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_digest(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + digest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest) +} +inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_digest(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + digest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest) +} +inline std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_mutable_digest() { + _has_bits_[0] |= 0x00000001u; + return digest_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return digest_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_allocated_digest(std::string* digest) { + if (digest != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + digest_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), digest); + // @@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 = (_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() { + origin_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_origin(const std::string& value) { + _internal_set_origin(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin) +} +inline std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::mutable_origin() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin) + return _internal_mutable_origin(); +} +inline const std::string& ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_origin() const { + return origin_.GetNoArena(); +} +inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_set_origin(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + origin_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_origin(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + origin_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin) +} +inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_origin(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + origin_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin) +} +inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_origin(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + origin_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin) +} +inline std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::_internal_mutable_origin() { + _has_bits_[0] |= 0x00000002u; + return origin_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return origin_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_allocated_origin(std::string* origin) { + if (origin != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + origin_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), origin); + // @@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 = (_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() { + type_ = 0; + _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 >(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)); + _has_bits_[0] |= 0x00000004u; + 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 = (_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() { + incident_time_msec_ = PROTOBUF_LONGLONG(0); + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ClientIncidentReport_IncidentData::_internal_incident_time_msec() const { + return incident_time_msec_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 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(::PROTOBUF_NAMESPACE_ID::int64 value) { + _has_bits_[0] |= 0x00000008u; + incident_time_msec_ = value; +} +inline void ClientIncidentReport_IncidentData::set_incident_time_msec(::PROTOBUF_NAMESPACE_ID::int64 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 = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || 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 (tracked_preference_ != nullptr) tracked_preference_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident& ClientIncidentReport_IncidentData::_internal_tracked_preference() const { + const ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* p = 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 ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* ClientIncidentReport_IncidentData::release_tracked_preference() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.tracked_preference) + _has_bits_[0] &= ~0x00000001u; + ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* temp = tracked_preference_; + tracked_preference_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* ClientIncidentReport_IncidentData::_internal_mutable_tracked_preference() { + _has_bits_[0] |= 0x00000001u; + if (tracked_preference_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident>(GetArenaNoVirtual()); + tracked_preference_ = p; + } + return tracked_preference_; +} +inline ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* ClientIncidentReport_IncidentData::mutable_tracked_preference() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.tracked_preference) + return _internal_mutable_tracked_preference(); +} +inline void ClientIncidentReport_IncidentData::set_allocated_tracked_preference(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* tracked_preference) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete tracked_preference_; + } + if (tracked_preference) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + tracked_preference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, tracked_preference, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + 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 = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || 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 (binary_integrity_ != nullptr) binary_integrity_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident& ClientIncidentReport_IncidentData::_internal_binary_integrity() const { + const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* p = 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 ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* ClientIncidentReport_IncidentData::release_binary_integrity() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.binary_integrity) + _has_bits_[0] &= ~0x00000002u; + ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* temp = binary_integrity_; + binary_integrity_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* ClientIncidentReport_IncidentData::_internal_mutable_binary_integrity() { + _has_bits_[0] |= 0x00000002u; + if (binary_integrity_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident>(GetArenaNoVirtual()); + binary_integrity_ = p; + } + return binary_integrity_; +} +inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* ClientIncidentReport_IncidentData::mutable_binary_integrity() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.binary_integrity) + return _internal_mutable_binary_integrity(); +} +inline void ClientIncidentReport_IncidentData::set_allocated_binary_integrity(::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* binary_integrity) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete binary_integrity_; + } + if (binary_integrity) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + binary_integrity = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, binary_integrity, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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 = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || 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 (resource_request_ != nullptr) resource_request_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident& ClientIncidentReport_IncidentData::_internal_resource_request() const { + const ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* p = 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 ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* ClientIncidentReport_IncidentData::release_resource_request() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.IncidentData.resource_request) + _has_bits_[0] &= ~0x00000004u; + ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* temp = resource_request_; + resource_request_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* ClientIncidentReport_IncidentData::_internal_mutable_resource_request() { + _has_bits_[0] |= 0x00000004u; + if (resource_request_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident>(GetArenaNoVirtual()); + resource_request_ = p; + } + return resource_request_; +} +inline ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* ClientIncidentReport_IncidentData::mutable_resource_request() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.resource_request) + return _internal_mutable_resource_request(); +} +inline void ClientIncidentReport_IncidentData::set_allocated_resource_request(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* resource_request) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete resource_request_; + } + if (resource_request) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + resource_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, resource_request, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientIncidentReport_DownloadDetails::has_token() const { + return _internal_has_token(); +} +inline void ClientIncidentReport_DownloadDetails::clear_token() { + token_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_DownloadDetails::set_token(const std::string& value) { + _internal_set_token(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.DownloadDetails.token) +} +inline std::string* ClientIncidentReport_DownloadDetails::mutable_token() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.DownloadDetails.token) + return _internal_mutable_token(); +} +inline const std::string& ClientIncidentReport_DownloadDetails::_internal_token() const { + return token_.GetNoArena(); +} +inline void ClientIncidentReport_DownloadDetails::_internal_set_token(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_DownloadDetails::set_token(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + token_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.DownloadDetails.token) +} +inline void ClientIncidentReport_DownloadDetails::set_token(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.DownloadDetails.token) +} +inline void ClientIncidentReport_DownloadDetails::set_token(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.DownloadDetails.token) +} +inline std::string* ClientIncidentReport_DownloadDetails::_internal_mutable_token() { + _has_bits_[0] |= 0x00000001u; + return token_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientIncidentReport_DownloadDetails::release_token() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.DownloadDetails.token) + if (!_internal_has_token()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return token_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_DownloadDetails::set_allocated_token(std::string* token) { + if (token != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + token_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), token); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || download_ != nullptr); + return value; +} +inline bool ClientIncidentReport_DownloadDetails::has_download() const { + return _internal_has_download(); +} +inline void ClientIncidentReport_DownloadDetails::clear_download() { + if (download_ != nullptr) download_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::safe_browsing::ClientDownloadRequest& ClientIncidentReport_DownloadDetails::_internal_download() const { + const ::safe_browsing::ClientDownloadRequest* p = 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 ::safe_browsing::ClientDownloadRequest* ClientIncidentReport_DownloadDetails::release_download() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.DownloadDetails.download) + _has_bits_[0] &= ~0x00000002u; + ::safe_browsing::ClientDownloadRequest* temp = download_; + download_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest* ClientIncidentReport_DownloadDetails::_internal_mutable_download() { + _has_bits_[0] |= 0x00000002u; + if (download_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest>(GetArenaNoVirtual()); + download_ = p; + } + return download_; +} +inline ::safe_browsing::ClientDownloadRequest* ClientIncidentReport_DownloadDetails::mutable_download() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.DownloadDetails.download) + return _internal_mutable_download(); +} +inline void ClientIncidentReport_DownloadDetails::set_allocated_download(::safe_browsing::ClientDownloadRequest* download) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete download_; + } + if (download) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + download = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, download, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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 = (_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() { + download_time_msec_ = PROTOBUF_LONGLONG(0); + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ClientIncidentReport_DownloadDetails::_internal_download_time_msec() const { + return download_time_msec_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 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(::PROTOBUF_NAMESPACE_ID::int64 value) { + _has_bits_[0] |= 0x00000004u; + download_time_msec_ = value; +} +inline void ClientIncidentReport_DownloadDetails::set_download_time_msec(::PROTOBUF_NAMESPACE_ID::int64 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 = (_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() { + open_time_msec_ = PROTOBUF_LONGLONG(0); + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ClientIncidentReport_DownloadDetails::_internal_open_time_msec() const { + return open_time_msec_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 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(::PROTOBUF_NAMESPACE_ID::int64 value) { + _has_bits_[0] |= 0x00000008u; + open_time_msec_ = value; +} +inline void ClientIncidentReport_DownloadDetails::set_open_time_msec(::PROTOBUF_NAMESPACE_ID::int64 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 = (_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() { + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name) +} +inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryValue::mutable_name() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name) + return _internal_mutable_name(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_name() const { + return name_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name) +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name) +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_name(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name) +} +inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name); + // @@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 = (_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() { + type_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_type() const { + return type_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 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(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000004u; + type_ = value; +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_type(::PROTOBUF_NAMESPACE_ID::uint32 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 = (_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() { + data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_data(const std::string& value) { + _internal_set_data(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.data) +} +inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryValue::mutable_data() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.data) + return _internal_mutable_data(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_data() const { + return data_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_set_data(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_data(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + data_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.data) +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_data(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.data) +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_data(const void* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.data) +} +inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryValue::_internal_mutable_data() { + _has_bits_[0] |= 0x00000002u; + return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return data_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_allocated_data(std::string* data) { + if (data != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data); + // @@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 = (_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() { + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.name) +} +inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryKey::mutable_name() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.name) + return _internal_mutable_name(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_name() const { + return name_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.name) +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.name) +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::set_name(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.name) +} +inline std::string* ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name); + // @@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 value_.size(); +} +inline int ClientIncidentReport_EnvironmentData_OS_RegistryKey::value_size() const { + return _internal_value_size(); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::clear_value() { + 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 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 &value_; +} +inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue& ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_value(int index) const { + return 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 value_.Add(); +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue* ClientIncidentReport_EnvironmentData_OS_RegistryKey::add_value() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.value) + return _internal_add_value(); +} +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 value_; +} + +// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey key = 3; +inline int ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_key_size() const { + return key_.size(); +} +inline int ClientIncidentReport_EnvironmentData_OS_RegistryKey::key_size() const { + return _internal_key_size(); +} +inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::clear_key() { + 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 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 &key_; +} +inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey& ClientIncidentReport_EnvironmentData_OS_RegistryKey::_internal_key(int index) const { + return 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 key_.Add(); +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* ClientIncidentReport_EnvironmentData_OS_RegistryKey::add_key() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.key) + return _internal_add_key(); +} +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 key_; +} + +// ------------------------------------------------------------------- + +// ClientIncidentReport_EnvironmentData_OS + +// optional string os_name = 1; +inline bool ClientIncidentReport_EnvironmentData_OS::_internal_has_os_name() const { + bool value = (_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() { + os_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_OS::set_os_name(const std::string& value) { + _internal_set_os_name(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name) +} +inline std::string* ClientIncidentReport_EnvironmentData_OS::mutable_os_name() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name) + return _internal_mutable_os_name(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_OS::_internal_os_name() const { + return os_name_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_OS::_internal_set_os_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + os_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_OS::set_os_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + os_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name) +} +inline void ClientIncidentReport_EnvironmentData_OS::set_os_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + os_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name) +} +inline void ClientIncidentReport_EnvironmentData_OS::set_os_name(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + os_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name) +} +inline std::string* ClientIncidentReport_EnvironmentData_OS::_internal_mutable_os_name() { + _has_bits_[0] |= 0x00000001u; + return os_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return os_name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_OS::set_allocated_os_name(std::string* os_name) { + if (os_name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + os_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), os_name); + // @@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 = (_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() { + os_version_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_OS::set_os_version(const std::string& value) { + _internal_set_os_version(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_version) +} +inline std::string* ClientIncidentReport_EnvironmentData_OS::mutable_os_version() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_version) + return _internal_mutable_os_version(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_OS::_internal_os_version() const { + return os_version_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_OS::_internal_set_os_version(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + os_version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_OS::set_os_version(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + os_version_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_version) +} +inline void ClientIncidentReport_EnvironmentData_OS::set_os_version(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + os_version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_version) +} +inline void ClientIncidentReport_EnvironmentData_OS::set_os_version(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + os_version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_version) +} +inline std::string* ClientIncidentReport_EnvironmentData_OS::_internal_mutable_os_version() { + _has_bits_[0] |= 0x00000002u; + return os_version_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return os_version_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_OS::set_allocated_os_version(std::string* os_version) { + if (os_version != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + os_version_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), os_version); + // @@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 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() { + 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 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 ®istry_key_; +} +inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey& ClientIncidentReport_EnvironmentData_OS::_internal_registry_key(int index) const { + return 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 registry_key_.Add(); +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* ClientIncidentReport_EnvironmentData_OS::add_registry_key() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.OS.registry_key) + return _internal_add_registry_key(); +} +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 registry_key_; +} + +// optional bool is_enrolled_to_domain = 4; +inline bool ClientIncidentReport_EnvironmentData_OS::_internal_has_is_enrolled_to_domain() const { + bool value = (_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() { + is_enrolled_to_domain_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool ClientIncidentReport_EnvironmentData_OS::_internal_is_enrolled_to_domain() const { + return 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) { + _has_bits_[0] |= 0x00000004u; + 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 = (_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() { + cpu_architecture_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_Machine::set_cpu_architecture(const std::string& value) { + _internal_set_cpu_architecture(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture) +} +inline std::string* ClientIncidentReport_EnvironmentData_Machine::mutable_cpu_architecture() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture) + return _internal_mutable_cpu_architecture(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_Machine::_internal_cpu_architecture() const { + return cpu_architecture_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_Machine::_internal_set_cpu_architecture(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + cpu_architecture_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_Machine::set_cpu_architecture(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + cpu_architecture_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture) +} +inline void ClientIncidentReport_EnvironmentData_Machine::set_cpu_architecture(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + cpu_architecture_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture) +} +inline void ClientIncidentReport_EnvironmentData_Machine::set_cpu_architecture(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + cpu_architecture_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture) +} +inline std::string* ClientIncidentReport_EnvironmentData_Machine::_internal_mutable_cpu_architecture() { + _has_bits_[0] |= 0x00000001u; + return cpu_architecture_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return cpu_architecture_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_Machine::set_allocated_cpu_architecture(std::string* cpu_architecture) { + if (cpu_architecture != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + cpu_architecture_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cpu_architecture); + // @@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 = (_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() { + cpu_vendor_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_Machine::set_cpu_vendor(const std::string& value) { + _internal_set_cpu_vendor(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor) +} +inline std::string* ClientIncidentReport_EnvironmentData_Machine::mutable_cpu_vendor() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor) + return _internal_mutable_cpu_vendor(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_Machine::_internal_cpu_vendor() const { + return cpu_vendor_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_Machine::_internal_set_cpu_vendor(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + cpu_vendor_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_Machine::set_cpu_vendor(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + cpu_vendor_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor) +} +inline void ClientIncidentReport_EnvironmentData_Machine::set_cpu_vendor(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + cpu_vendor_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor) +} +inline void ClientIncidentReport_EnvironmentData_Machine::set_cpu_vendor(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + cpu_vendor_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor) +} +inline std::string* ClientIncidentReport_EnvironmentData_Machine::_internal_mutable_cpu_vendor() { + _has_bits_[0] |= 0x00000002u; + return cpu_vendor_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return cpu_vendor_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_Machine::set_allocated_cpu_vendor(std::string* cpu_vendor) { + if (cpu_vendor != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + cpu_vendor_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cpu_vendor); + // @@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 = (_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() { + cpuid_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIncidentReport_EnvironmentData_Machine::_internal_cpuid() const { + return cpuid_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 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(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000004u; + cpuid_ = value; +} +inline void ClientIncidentReport_EnvironmentData_Machine::set_cpuid(::PROTOBUF_NAMESPACE_ID::uint32 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 = (_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() { + function_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_function(const std::string& value) { + _internal_set_function(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function) +} +inline std::string* ClientIncidentReport_EnvironmentData_Process_Patch::mutable_function() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function) + return _internal_mutable_function(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_Process_Patch::_internal_function() const { + return function_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_Process_Patch::_internal_set_function(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + function_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_function(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + function_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function) +} +inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_function(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + function_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function) +} +inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_function(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + function_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function) +} +inline std::string* ClientIncidentReport_EnvironmentData_Process_Patch::_internal_mutable_function() { + _has_bits_[0] |= 0x00000001u; + return function_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return function_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_allocated_function(std::string* function) { + if (function != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + function_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), function); + // @@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 = (_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() { + target_dll_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_target_dll(const std::string& value) { + _internal_set_target_dll(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.target_dll) +} +inline std::string* ClientIncidentReport_EnvironmentData_Process_Patch::mutable_target_dll() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.target_dll) + return _internal_mutable_target_dll(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_Process_Patch::_internal_target_dll() const { + return target_dll_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_Process_Patch::_internal_set_target_dll(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + target_dll_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_target_dll(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + target_dll_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.target_dll) +} +inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_target_dll(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + target_dll_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.target_dll) +} +inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_target_dll(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + target_dll_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.target_dll) +} +inline std::string* ClientIncidentReport_EnvironmentData_Process_Patch::_internal_mutable_target_dll() { + _has_bits_[0] |= 0x00000002u; + return target_dll_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return target_dll_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_allocated_target_dll(std::string* target_dll) { + if (target_dll != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + target_dll_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), target_dll); + // @@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 = (_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() { + path_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_path(const std::string& value) { + _internal_set_path(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path) +} +inline std::string* ClientIncidentReport_EnvironmentData_Process_Dll::mutable_path() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path) + return _internal_mutable_path(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_Process_Dll::_internal_path() const { + return path_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_Process_Dll::_internal_set_path(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_path(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + path_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path) +} +inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_path(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path) +} +inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_path(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path) +} +inline std::string* ClientIncidentReport_EnvironmentData_Process_Dll::_internal_mutable_path() { + _has_bits_[0] |= 0x00000001u; + return path_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return path_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_allocated_path(std::string* path) { + if (path != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + path_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), path); + // @@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 = (_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() { + base_address_ = PROTOBUF_ULONGLONG(0); + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 ClientIncidentReport_EnvironmentData_Process_Dll::_internal_base_address() const { + return base_address_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 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(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _has_bits_[0] |= 0x00000004u; + base_address_ = value; +} +inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_base_address(::PROTOBUF_NAMESPACE_ID::uint64 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 = (_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() { + length_ = 0u; + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIncidentReport_EnvironmentData_Process_Dll::_internal_length() const { + return length_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 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(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000008u; + length_ = value; +} +inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_length(::PROTOBUF_NAMESPACE_ID::uint32 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 feature_.size(); +} +inline int ClientIncidentReport_EnvironmentData_Process_Dll::feature_size() const { + return _internal_feature_size(); +} +inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_feature() { + 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 >(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)); + 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)); + feature_.Add(value); +} +inline void ClientIncidentReport_EnvironmentData_Process_Dll::add_feature(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature value) { + // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.feature) + _internal_add_feature(value); +} +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 feature_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* +ClientIncidentReport_EnvironmentData_Process_Dll::_internal_mutable_feature() { + return &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 = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || 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 (image_headers_ != nullptr) image_headers_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientIncidentReport_EnvironmentData_Process_Dll::_internal_image_headers() const { + const ::safe_browsing::ClientDownloadRequest_ImageHeaders* p = 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 ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_EnvironmentData_Process_Dll::release_image_headers() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.image_headers) + _has_bits_[0] &= ~0x00000002u; + ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = image_headers_; + image_headers_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_EnvironmentData_Process_Dll::_internal_mutable_image_headers() { + _has_bits_[0] |= 0x00000002u; + if (image_headers_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientDownloadRequest_ImageHeaders>(GetArenaNoVirtual()); + image_headers_ = p; + } + return image_headers_; +} +inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_EnvironmentData_Process_Dll::mutable_image_headers() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.image_headers) + return _internal_mutable_image_headers(); +} +inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete image_headers_; + } + if (image_headers) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + image_headers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, image_headers, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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 = (_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() { + file_offset_ = 0u; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_file_offset() const { + return file_offset_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 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(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000004u; + file_offset_ = value; +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_file_offset(::PROTOBUF_NAMESPACE_ID::uint32 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 = (_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() { + byte_count_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_byte_count() const { + return byte_count_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000008u; + byte_count_ = value; +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_byte_count(::PROTOBUF_NAMESPACE_ID::int32 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 = (_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() { + modified_bytes_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_modified_bytes(const std::string& value) { + _internal_set_modified_bytes(value); + // @@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() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.modified_bytes) + return _internal_mutable_modified_bytes(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_modified_bytes() const { + return modified_bytes_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_set_modified_bytes(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + modified_bytes_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_modified_bytes(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + modified_bytes_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.modified_bytes) +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_modified_bytes(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + modified_bytes_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.modified_bytes) +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_modified_bytes(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + modified_bytes_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.modified_bytes) +} +inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_mutable_modified_bytes() { + _has_bits_[0] |= 0x00000001u; + return modified_bytes_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return modified_bytes_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_allocated_modified_bytes(std::string* modified_bytes) { + if (modified_bytes != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + modified_bytes_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), modified_bytes); + // @@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 = (_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() { + export_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_export_name(const std::string& value) { + _internal_set_export_name(value); + // @@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() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.export_name) + return _internal_mutable_export_name(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_export_name() const { + return export_name_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_set_export_name(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + export_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_export_name(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + export_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.export_name) +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_export_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + export_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.export_name) +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_export_name(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + export_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.export_name) +} +inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::_internal_mutable_export_name() { + _has_bits_[0] |= 0x00000002u; + return export_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return export_name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_allocated_export_name(std::string* export_name) { + if (export_name != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + export_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), export_name); + // @@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 = (_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() { + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.name) +} +inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState::mutable_name() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.name) + return _internal_mutable_name(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_name() const { + return name_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.name) +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.name) +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_name(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.name) +} +inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name); + // @@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 = (_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() { + modified_state_ = 0; + _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 >(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)); + _has_bits_[0] |= 0x00000002u; + 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 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() { + obsolete_modified_export_.Clear(); +} +inline std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState::add_obsolete_modified_export() { + // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export) + return _internal_add_obsolete_modified_export(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_obsolete_modified_export(int index) const { + return 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 obsolete_modified_export_.Mutable(index); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_obsolete_modified_export(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export) + obsolete_modified_export_.Mutable(index)->assign(value); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_obsolete_modified_export(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.OBSOLETE_modified_export) + obsolete_modified_export_.Mutable(index)->assign(std::move(value)); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_obsolete_modified_export(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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) { + 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 obsolete_modified_export_.Add(); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::add_obsolete_modified_export(const std::string& value) { + 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) { + 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); + 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) { + 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 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 &obsolete_modified_export_; +} + +// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification modification = 4; +inline int ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_modification_size() const { + return modification_.size(); +} +inline int ClientIncidentReport_EnvironmentData_Process_ModuleState::modification_size() const { + return _internal_modification_size(); +} +inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::clear_modification() { + 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 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 &modification_; +} +inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& ClientIncidentReport_EnvironmentData_Process_ModuleState::_internal_modification(int index) const { + return 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 modification_.Add(); +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* ClientIncidentReport_EnvironmentData_Process_ModuleState::add_modification() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.modification) + return _internal_add_modification(); +} +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 modification_; +} + +// ------------------------------------------------------------------- + +// ClientIncidentReport_EnvironmentData_Process + +// optional string version = 1; +inline bool ClientIncidentReport_EnvironmentData_Process::_internal_has_version() const { + bool value = (_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() { + version_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_EnvironmentData_Process::set_version(const std::string& value) { + _internal_set_version(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version) +} +inline std::string* ClientIncidentReport_EnvironmentData_Process::mutable_version() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version) + return _internal_mutable_version(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_Process::_internal_version() const { + return version_.GetNoArena(); +} +inline void ClientIncidentReport_EnvironmentData_Process::_internal_set_version(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_EnvironmentData_Process::set_version(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + version_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version) +} +inline void ClientIncidentReport_EnvironmentData_Process::set_version(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version) +} +inline void ClientIncidentReport_EnvironmentData_Process::set_version(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version) +} +inline std::string* ClientIncidentReport_EnvironmentData_Process::_internal_mutable_version() { + _has_bits_[0] |= 0x00000001u; + return version_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return version_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_EnvironmentData_Process::set_allocated_version(std::string* version) { + if (version != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + version_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), version); + // @@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 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() { + obsolete_dlls_.Clear(); +} +inline std::string* ClientIncidentReport_EnvironmentData_Process::add_obsolete_dlls() { + // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls) + return _internal_add_obsolete_dlls(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_Process::_internal_obsolete_dlls(int index) const { + return 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 obsolete_dlls_.Mutable(index); +} +inline void ClientIncidentReport_EnvironmentData_Process::set_obsolete_dlls(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls) + obsolete_dlls_.Mutable(index)->assign(value); +} +inline void ClientIncidentReport_EnvironmentData_Process::set_obsolete_dlls(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.OBSOLETE_dlls) + obsolete_dlls_.Mutable(index)->assign(std::move(value)); +} +inline void ClientIncidentReport_EnvironmentData_Process::set_obsolete_dlls(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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) { + 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 obsolete_dlls_.Add(); +} +inline void ClientIncidentReport_EnvironmentData_Process::add_obsolete_dlls(const std::string& value) { + 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) { + 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); + 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) { + 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 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 &obsolete_dlls_; +} + +// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch patches = 3; +inline int ClientIncidentReport_EnvironmentData_Process::_internal_patches_size() const { + return patches_.size(); +} +inline int ClientIncidentReport_EnvironmentData_Process::patches_size() const { + return _internal_patches_size(); +} +inline void ClientIncidentReport_EnvironmentData_Process::clear_patches() { + 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 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 &patches_; +} +inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch& ClientIncidentReport_EnvironmentData_Process::_internal_patches(int index) const { + return 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 patches_.Add(); +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch* ClientIncidentReport_EnvironmentData_Process::add_patches() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.patches) + return _internal_add_patches(); +} +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 patches_; +} + +// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider network_providers = 4; +inline int ClientIncidentReport_EnvironmentData_Process::_internal_network_providers_size() const { + return 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() { + 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 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 &network_providers_; +} +inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider& ClientIncidentReport_EnvironmentData_Process::_internal_network_providers(int index) const { + return 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 network_providers_.Add(); +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider* ClientIncidentReport_EnvironmentData_Process::add_network_providers() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.network_providers) + return _internal_add_network_providers(); +} +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 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 = (_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() { + chrome_update_channel_ = 0; + _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 >(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)); + _has_bits_[0] |= 0x00000004u; + 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 = (_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() { + uptime_msec_ = PROTOBUF_LONGLONG(0); + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ClientIncidentReport_EnvironmentData_Process::_internal_uptime_msec() const { + return uptime_msec_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 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(::PROTOBUF_NAMESPACE_ID::int64 value) { + _has_bits_[0] |= 0x00000002u; + uptime_msec_ = value; +} +inline void ClientIncidentReport_EnvironmentData_Process::set_uptime_msec(::PROTOBUF_NAMESPACE_ID::int64 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 = (_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() { + metrics_consent_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool ClientIncidentReport_EnvironmentData_Process::_internal_metrics_consent() const { + return 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) { + _has_bits_[0] |= 0x00000008u; + 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 = (_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() { + obsolete_extended_consent_ = false; + _has_bits_[0] &= ~0x00000010u; +} +inline bool ClientIncidentReport_EnvironmentData_Process::_internal_obsolete_extended_consent() const { + return 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) { + _has_bits_[0] |= 0x00000010u; + 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 dll_.size(); +} +inline int ClientIncidentReport_EnvironmentData_Process::dll_size() const { + return _internal_dll_size(); +} +inline void ClientIncidentReport_EnvironmentData_Process::clear_dll() { + 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 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 &dll_; +} +inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll& ClientIncidentReport_EnvironmentData_Process::_internal_dll(int index) const { + return 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 dll_.Add(); +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll* ClientIncidentReport_EnvironmentData_Process::add_dll() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.dll) + return _internal_add_dll(); +} +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 dll_; +} + +// repeated string blacklisted_dll = 10; +inline int ClientIncidentReport_EnvironmentData_Process::_internal_blacklisted_dll_size() const { + return 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() { + blacklisted_dll_.Clear(); +} +inline std::string* ClientIncidentReport_EnvironmentData_Process::add_blacklisted_dll() { + // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll) + return _internal_add_blacklisted_dll(); +} +inline const std::string& ClientIncidentReport_EnvironmentData_Process::_internal_blacklisted_dll(int index) const { + return 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 blacklisted_dll_.Mutable(index); +} +inline void ClientIncidentReport_EnvironmentData_Process::set_blacklisted_dll(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll) + blacklisted_dll_.Mutable(index)->assign(value); +} +inline void ClientIncidentReport_EnvironmentData_Process::set_blacklisted_dll(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.blacklisted_dll) + blacklisted_dll_.Mutable(index)->assign(std::move(value)); +} +inline void ClientIncidentReport_EnvironmentData_Process::set_blacklisted_dll(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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) { + 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 blacklisted_dll_.Add(); +} +inline void ClientIncidentReport_EnvironmentData_Process::add_blacklisted_dll(const std::string& value) { + 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) { + 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); + 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) { + 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 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 &blacklisted_dll_; +} + +// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState module_state = 11; +inline int ClientIncidentReport_EnvironmentData_Process::_internal_module_state_size() const { + return 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() { + 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 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 &module_state_; +} +inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState& ClientIncidentReport_EnvironmentData_Process::_internal_module_state(int index) const { + return 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 module_state_.Add(); +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState* ClientIncidentReport_EnvironmentData_Process::add_module_state() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.module_state) + return _internal_add_module_state(); +} +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 module_state_; +} + +// optional bool OBSOLETE_field_trial_participant = 12; +inline bool ClientIncidentReport_EnvironmentData_Process::_internal_has_obsolete_field_trial_participant() const { + bool value = (_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() { + obsolete_field_trial_participant_ = false; + _has_bits_[0] &= ~0x00000020u; +} +inline bool ClientIncidentReport_EnvironmentData_Process::_internal_obsolete_field_trial_participant() const { + return 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) { + _has_bits_[0] |= 0x00000020u; + 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 = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || os_ != nullptr); + return value; +} +inline bool ClientIncidentReport_EnvironmentData::has_os() const { + return _internal_has_os(); +} +inline void ClientIncidentReport_EnvironmentData::clear_os() { + if (os_ != nullptr) os_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS& ClientIncidentReport_EnvironmentData::_internal_os() const { + const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* p = 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 ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* ClientIncidentReport_EnvironmentData::release_os() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.os) + _has_bits_[0] &= ~0x00000001u; + ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* temp = os_; + os_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* ClientIncidentReport_EnvironmentData::_internal_mutable_os() { + _has_bits_[0] |= 0x00000001u; + if (os_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_OS>(GetArenaNoVirtual()); + os_ = p; + } + return os_; +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* ClientIncidentReport_EnvironmentData::mutable_os() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.os) + return _internal_mutable_os(); +} +inline void ClientIncidentReport_EnvironmentData::set_allocated_os(::safe_browsing::ClientIncidentReport_EnvironmentData_OS* os) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete os_; + } + if (os) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + os = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, os, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + 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 = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || machine_ != nullptr); + return value; +} +inline bool ClientIncidentReport_EnvironmentData::has_machine() const { + return _internal_has_machine(); +} +inline void ClientIncidentReport_EnvironmentData::clear_machine() { + if (machine_ != nullptr) machine_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine& ClientIncidentReport_EnvironmentData::_internal_machine() const { + const ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* p = 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 ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* ClientIncidentReport_EnvironmentData::release_machine() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.machine) + _has_bits_[0] &= ~0x00000002u; + ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* temp = machine_; + machine_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* ClientIncidentReport_EnvironmentData::_internal_mutable_machine() { + _has_bits_[0] |= 0x00000002u; + if (machine_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_Machine>(GetArenaNoVirtual()); + machine_ = p; + } + return machine_; +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* ClientIncidentReport_EnvironmentData::mutable_machine() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.machine) + return _internal_mutable_machine(); +} +inline void ClientIncidentReport_EnvironmentData::set_allocated_machine(::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* machine) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete machine_; + } + if (machine) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + machine = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, machine, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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 = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || process_ != nullptr); + return value; +} +inline bool ClientIncidentReport_EnvironmentData::has_process() const { + return _internal_has_process(); +} +inline void ClientIncidentReport_EnvironmentData::clear_process() { + if (process_ != nullptr) process_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process& ClientIncidentReport_EnvironmentData::_internal_process() const { + const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* p = 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 ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* ClientIncidentReport_EnvironmentData::release_process() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.EnvironmentData.process) + _has_bits_[0] &= ~0x00000004u; + ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* temp = process_; + process_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* ClientIncidentReport_EnvironmentData::_internal_mutable_process() { + _has_bits_[0] |= 0x00000004u; + if (process_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData_Process>(GetArenaNoVirtual()); + process_ = p; + } + return process_; +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* ClientIncidentReport_EnvironmentData::mutable_process() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.process) + return _internal_mutable_process(); +} +inline void ClientIncidentReport_EnvironmentData::set_allocated_process(::safe_browsing::ClientIncidentReport_EnvironmentData_Process* process) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete process_; + } + if (process) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + process = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, process, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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 = (_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() { + id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_id(const std::string& value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id) +} +inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_id() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id) + return _internal_mutable_id(); +} +inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_id() const { + return id_.GetNoArena(); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_id(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_id(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + id_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id) +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_id(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id) +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_id(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id) +} +inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_mutable_id() { + _has_bits_[0] |= 0x00000001u; + return id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return id_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_id(std::string* id) { + if (id != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id); + // @@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 = (_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() { + version_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_version(const std::string& value) { + _internal_set_version(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version) +} +inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_version() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version) + return _internal_mutable_version(); +} +inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_version() const { + return version_.GetNoArena(); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_version(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_version(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + version_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version) +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_version(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version) +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_version(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version) +} +inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_mutable_version() { + _has_bits_[0] |= 0x00000002u; + return version_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return version_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_version(std::string* version) { + if (version != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + version_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), version); + // @@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 = (_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() { + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name) +} +inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_name() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name) + return _internal_mutable_name(); +} +inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_name() const { + return name_.GetNoArena(); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name) +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name) +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_name(const char* value, size_t size) { + _has_bits_[0] |= 0x00000004u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name) +} +inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_mutable_name() { + _has_bits_[0] |= 0x00000004u; + return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000004u; + return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name); + // @@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 = (_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() { + description_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_description(const std::string& value) { + _internal_set_description(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description) +} +inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_description() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description) + return _internal_mutable_description(); +} +inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_description() const { + return description_.GetNoArena(); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_description(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_description(std::string&& value) { + _has_bits_[0] |= 0x00000008u; + description_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description) +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_description(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000008u; + description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description) +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_description(const char* value, size_t size) { + _has_bits_[0] |= 0x00000008u; + description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description) +} +inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_mutable_description() { + _has_bits_[0] |= 0x00000008u; + return description_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000008u; + return description_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_description(std::string* description) { + if (description != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + description_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description); + // @@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 = (_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() { + state_ = 0; + _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 >(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)); + _has_bits_[0] |= 0x00000040u; + 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 = (_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() { + type_ = 0; + _has_bits_[0] &= ~0x00000080u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_type() const { + return type_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000080u; + type_ = value; +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_type(::PROTOBUF_NAMESPACE_ID::int32 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 = (_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() { + update_url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_update_url(const std::string& value) { + _internal_set_update_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url) +} +inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_update_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url) + return _internal_mutable_update_url(); +} +inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_update_url() const { + return update_url_.GetNoArena(); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_update_url(const std::string& value) { + _has_bits_[0] |= 0x00000010u; + update_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_update_url(std::string&& value) { + _has_bits_[0] |= 0x00000010u; + update_url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url) +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_update_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000010u; + update_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url) +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_update_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000010u; + update_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url) +} +inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_mutable_update_url() { + _has_bits_[0] |= 0x00000010u; + return update_url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000010u; + return update_url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_update_url(std::string* update_url) { + if (update_url != nullptr) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + update_url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), update_url); + // @@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 = (_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() { + has_signature_validation_ = false; + _has_bits_[0] &= ~0x00000100u; +} +inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_has_signature_validation() const { + return 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) { + _has_bits_[0] |= 0x00000100u; + 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 = (_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() { + signature_is_valid_ = false; + _has_bits_[0] &= ~0x00000200u; +} +inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_signature_is_valid() const { + return 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) { + _has_bits_[0] |= 0x00000200u; + 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 = (_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() { + installed_by_custodian_ = false; + _has_bits_[0] &= ~0x00000400u; +} +inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_installed_by_custodian() const { + return 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) { + _has_bits_[0] |= 0x00000400u; + 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 = (_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() { + installed_by_default_ = false; + _has_bits_[0] &= ~0x00000800u; +} +inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_installed_by_default() const { + return 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) { + _has_bits_[0] |= 0x00000800u; + 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 = (_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() { + installed_by_oem_ = false; + _has_bits_[0] &= ~0x00001000u; +} +inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_installed_by_oem() const { + return 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) { + _has_bits_[0] |= 0x00001000u; + 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 = (_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() { + from_bookmark_ = false; + _has_bits_[0] &= ~0x00002000u; +} +inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_from_bookmark() const { + return 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) { + _has_bits_[0] |= 0x00002000u; + 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 = (_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() { + from_webstore_ = false; + _has_bits_[0] &= ~0x00004000u; +} +inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_from_webstore() const { + return 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) { + _has_bits_[0] |= 0x00004000u; + 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 = (_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() { + converted_from_user_script_ = false; + _has_bits_[0] &= ~0x00008000u; +} +inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_converted_from_user_script() const { + return 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) { + _has_bits_[0] |= 0x00008000u; + 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 = (_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() { + may_be_untrusted_ = false; + _has_bits_[0] &= ~0x00020000u; +} +inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_may_be_untrusted() const { + return 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) { + _has_bits_[0] |= 0x00020000u; + 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 = (_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() { + install_time_msec_ = PROTOBUF_LONGLONG(0); + _has_bits_[0] &= ~0x00010000u; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_install_time_msec() const { + return install_time_msec_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 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(::PROTOBUF_NAMESPACE_ID::int64 value) { + _has_bits_[0] |= 0x00010000u; + install_time_msec_ = value; +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_install_time_msec(::PROTOBUF_NAMESPACE_ID::int64 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 = (_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() { + manifest_location_type_ = 0; + _has_bits_[0] &= ~0x00040000u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_manifest_location_type() const { + return manifest_location_type_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00040000u; + manifest_location_type_ = value; +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_manifest_location_type(::PROTOBUF_NAMESPACE_ID::int32 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 = (_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() { + manifest_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_manifest(const std::string& value) { + _internal_set_manifest(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest) +} +inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_manifest() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest) + return _internal_mutable_manifest(); +} +inline const std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_manifest() const { + return manifest_.GetNoArena(); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_set_manifest(const std::string& value) { + _has_bits_[0] |= 0x00000020u; + manifest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_manifest(std::string&& value) { + _has_bits_[0] |= 0x00000020u; + manifest_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest) +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_manifest(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000020u; + manifest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest) +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_manifest(const char* value, size_t size) { + _has_bits_[0] |= 0x00000020u; + manifest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest) +} +inline std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::_internal_mutable_manifest() { + _has_bits_[0] |= 0x00000020u; + return manifest_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000020u; + return manifest_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_manifest(std::string* manifest) { + if (manifest != nullptr) { + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + manifest_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), manifest); + // @@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 = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || 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 (last_installed_extension_ != nullptr) last_installed_extension_->Clear(); + _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 = 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 ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* ClientIncidentReport_ExtensionData::release_last_installed_extension() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.ExtensionData.last_installed_extension) + _has_bits_[0] &= ~0x00000001u; + ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* temp = last_installed_extension_; + last_installed_extension_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* ClientIncidentReport_ExtensionData::_internal_mutable_last_installed_extension() { + _has_bits_[0] |= 0x00000001u; + if (last_installed_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo>(GetArenaNoVirtual()); + last_installed_extension_ = p; + } + return last_installed_extension_; +} +inline ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* ClientIncidentReport_ExtensionData::mutable_last_installed_extension() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.last_installed_extension) + return _internal_mutable_last_installed_extension(); +} +inline void ClientIncidentReport_ExtensionData::set_allocated_last_installed_extension(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* last_installed_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete last_installed_extension_; + } + if (last_installed_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + last_installed_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, last_installed_extension, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + 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 = (_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() { + file_type_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_file_type(const std::string& value) { + _internal_set_file_type(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type) +} +inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::mutable_file_type() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type) + return _internal_mutable_file_type(); +} +inline const std::string& ClientIncidentReport_NonBinaryDownloadDetails::_internal_file_type() const { + return file_type_.GetNoArena(); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::_internal_set_file_type(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + file_type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_file_type(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + file_type_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type) +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_file_type(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + file_type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type) +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_file_type(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + file_type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type) +} +inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::_internal_mutable_file_type() { + _has_bits_[0] |= 0x00000001u; + return file_type_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return file_type_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_allocated_file_type(std::string* file_type) { + if (file_type != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + file_type_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), file_type); + // @@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 = (_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() { + url_spec_sha256_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_url_spec_sha256(const std::string& value) { + _internal_set_url_spec_sha256(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256) +} +inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::mutable_url_spec_sha256() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256) + return _internal_mutable_url_spec_sha256(); +} +inline const std::string& ClientIncidentReport_NonBinaryDownloadDetails::_internal_url_spec_sha256() const { + return url_spec_sha256_.GetNoArena(); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::_internal_set_url_spec_sha256(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + url_spec_sha256_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_url_spec_sha256(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + url_spec_sha256_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256) +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_url_spec_sha256(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + url_spec_sha256_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256) +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_url_spec_sha256(const void* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + url_spec_sha256_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256) +} +inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::_internal_mutable_url_spec_sha256() { + _has_bits_[0] |= 0x00000002u; + return url_spec_sha256_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return url_spec_sha256_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_allocated_url_spec_sha256(std::string* url_spec_sha256) { + if (url_spec_sha256 != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + url_spec_sha256_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url_spec_sha256); + // @@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 = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ClientIncidentReport_NonBinaryDownloadDetails::has_host() const { + return _internal_has_host(); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_host() { + host_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_host(const std::string& value) { + _internal_set_host(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host) +} +inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::mutable_host() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host) + return _internal_mutable_host(); +} +inline const std::string& ClientIncidentReport_NonBinaryDownloadDetails::_internal_host() const { + return host_.GetNoArena(); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::_internal_set_host(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + host_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_host(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + host_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host) +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_host(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + host_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host) +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_host(const char* value, size_t size) { + _has_bits_[0] |= 0x00000004u; + host_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host) +} +inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::_internal_mutable_host() { + _has_bits_[0] |= 0x00000004u; + return host_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientIncidentReport_NonBinaryDownloadDetails::release_host() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host) + if (!_internal_has_host()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + return host_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_allocated_host(std::string* host) { + if (host != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + host_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), host); + // @@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 = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ClientIncidentReport_NonBinaryDownloadDetails::has_length() const { + return _internal_has_length(); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_length() { + length_ = PROTOBUF_LONGLONG(0); + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ClientIncidentReport_NonBinaryDownloadDetails::_internal_length() const { + return length_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ClientIncidentReport_NonBinaryDownloadDetails::length() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.length) + return _internal_length(); +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int64 value) { + _has_bits_[0] |= 0x00000008u; + length_ = value; +} +inline void ClientIncidentReport_NonBinaryDownloadDetails::set_length(::PROTOBUF_NAMESPACE_ID::int64 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 incident_.size(); +} +inline int ClientIncidentReport::incident_size() const { + return _internal_incident_size(); +} +inline void ClientIncidentReport::clear_incident() { + incident_.Clear(); +} +inline ::safe_browsing::ClientIncidentReport_IncidentData* ClientIncidentReport::mutable_incident(int index) { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.incident) + return 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 &incident_; +} +inline const ::safe_browsing::ClientIncidentReport_IncidentData& ClientIncidentReport::_internal_incident(int index) const { + return 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 incident_.Add(); +} +inline ::safe_browsing::ClientIncidentReport_IncidentData* ClientIncidentReport::add_incident() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.incident) + return _internal_add_incident(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData >& +ClientIncidentReport::incident() const { + // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.incident) + return incident_; +} + +// optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2; +inline bool ClientIncidentReport::_internal_has_download() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || download_ != nullptr); + return value; +} +inline bool ClientIncidentReport::has_download() const { + return _internal_has_download(); +} +inline void ClientIncidentReport::clear_download() { + if (download_ != nullptr) download_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::safe_browsing::ClientIncidentReport_DownloadDetails& ClientIncidentReport::_internal_download() const { + const ::safe_browsing::ClientIncidentReport_DownloadDetails* p = 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 ::safe_browsing::ClientIncidentReport_DownloadDetails* ClientIncidentReport::release_download() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.download) + _has_bits_[0] &= ~0x00000001u; + ::safe_browsing::ClientIncidentReport_DownloadDetails* temp = download_; + download_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientIncidentReport_DownloadDetails* ClientIncidentReport::_internal_mutable_download() { + _has_bits_[0] |= 0x00000001u; + if (download_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_DownloadDetails>(GetArenaNoVirtual()); + download_ = p; + } + return download_; +} +inline ::safe_browsing::ClientIncidentReport_DownloadDetails* ClientIncidentReport::mutable_download() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.download) + return _internal_mutable_download(); +} +inline void ClientIncidentReport::set_allocated_download(::safe_browsing::ClientIncidentReport_DownloadDetails* download) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete download_; + } + if (download) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + download = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, download, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + 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 = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || environment_ != nullptr); + return value; +} +inline bool ClientIncidentReport::has_environment() const { + return _internal_has_environment(); +} +inline void ClientIncidentReport::clear_environment() { + if (environment_ != nullptr) environment_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::safe_browsing::ClientIncidentReport_EnvironmentData& ClientIncidentReport::_internal_environment() const { + const ::safe_browsing::ClientIncidentReport_EnvironmentData* p = 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 ::safe_browsing::ClientIncidentReport_EnvironmentData* ClientIncidentReport::release_environment() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.environment) + _has_bits_[0] &= ~0x00000002u; + ::safe_browsing::ClientIncidentReport_EnvironmentData* temp = environment_; + environment_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData* ClientIncidentReport::_internal_mutable_environment() { + _has_bits_[0] |= 0x00000002u; + if (environment_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_EnvironmentData>(GetArenaNoVirtual()); + environment_ = p; + } + return environment_; +} +inline ::safe_browsing::ClientIncidentReport_EnvironmentData* ClientIncidentReport::mutable_environment() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.environment) + return _internal_mutable_environment(); +} +inline void ClientIncidentReport::set_allocated_environment(::safe_browsing::ClientIncidentReport_EnvironmentData* environment) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete environment_; + } + if (environment) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + environment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, environment, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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 = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || population_ != nullptr); + return value; +} +inline bool ClientIncidentReport::has_population() const { + return _internal_has_population(); +} +inline void ClientIncidentReport::clear_population() { + if (population_ != nullptr) population_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::safe_browsing::ChromeUserPopulation& ClientIncidentReport::_internal_population() const { + const ::safe_browsing::ChromeUserPopulation* p = 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 ::safe_browsing::ChromeUserPopulation* ClientIncidentReport::release_population() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.population) + _has_bits_[0] &= ~0x00000004u; + ::safe_browsing::ChromeUserPopulation* temp = population_; + population_ = nullptr; + return temp; +} +inline ::safe_browsing::ChromeUserPopulation* ClientIncidentReport::_internal_mutable_population() { + _has_bits_[0] |= 0x00000004u; + if (population_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ChromeUserPopulation>(GetArenaNoVirtual()); + population_ = p; + } + return population_; +} +inline ::safe_browsing::ChromeUserPopulation* ClientIncidentReport::mutable_population() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.population) + return _internal_mutable_population(); +} +inline void ClientIncidentReport::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete population_; + } + if (population) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + population = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, population, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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 = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || extension_data_ != nullptr); + return value; +} +inline bool ClientIncidentReport::has_extension_data() const { + return _internal_has_extension_data(); +} +inline void ClientIncidentReport::clear_extension_data() { + if (extension_data_ != nullptr) extension_data_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::safe_browsing::ClientIncidentReport_ExtensionData& ClientIncidentReport::_internal_extension_data() const { + const ::safe_browsing::ClientIncidentReport_ExtensionData* p = 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 ::safe_browsing::ClientIncidentReport_ExtensionData* ClientIncidentReport::release_extension_data() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.extension_data) + _has_bits_[0] &= ~0x00000008u; + ::safe_browsing::ClientIncidentReport_ExtensionData* temp = extension_data_; + extension_data_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientIncidentReport_ExtensionData* ClientIncidentReport::_internal_mutable_extension_data() { + _has_bits_[0] |= 0x00000008u; + if (extension_data_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_ExtensionData>(GetArenaNoVirtual()); + extension_data_ = p; + } + return extension_data_; +} +inline ::safe_browsing::ClientIncidentReport_ExtensionData* ClientIncidentReport::mutable_extension_data() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.extension_data) + return _internal_mutable_extension_data(); +} +inline void ClientIncidentReport::set_allocated_extension_data(::safe_browsing::ClientIncidentReport_ExtensionData* extension_data) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete extension_data_; + } + if (extension_data) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + extension_data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_data, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + 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 = (_has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || 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 (non_binary_download_ != nullptr) non_binary_download_->Clear(); + _has_bits_[0] &= ~0x00000010u; +} +inline const ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails& ClientIncidentReport::_internal_non_binary_download() const { + const ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* p = 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 ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* ClientIncidentReport::release_non_binary_download() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentReport.non_binary_download) + _has_bits_[0] &= ~0x00000010u; + ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* temp = non_binary_download_; + non_binary_download_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* ClientIncidentReport::_internal_mutable_non_binary_download() { + _has_bits_[0] |= 0x00000010u; + if (non_binary_download_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails>(GetArenaNoVirtual()); + non_binary_download_ = p; + } + return non_binary_download_; +} +inline ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* ClientIncidentReport::mutable_non_binary_download() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.non_binary_download) + return _internal_mutable_non_binary_download(); +} +inline void ClientIncidentReport::set_allocated_non_binary_download(::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* non_binary_download) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete non_binary_download_; + } + if (non_binary_download) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + non_binary_download = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, non_binary_download, submessage_arena); + } + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + 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 = (_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() { + dll_index_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientIncidentResponse_EnvironmentRequest::_internal_dll_index() const { + return dll_index_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000001u; + dll_index_ = value; +} +inline void ClientIncidentResponse_EnvironmentRequest::set_dll_index(::PROTOBUF_NAMESPACE_ID::int32 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientIncidentResponse::has_token() const { + return _internal_has_token(); +} +inline void ClientIncidentResponse::clear_token() { + token_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientIncidentResponse::token() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentResponse.token) + return _internal_token(); +} +inline void ClientIncidentResponse::set_token(const std::string& value) { + _internal_set_token(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentResponse.token) +} +inline std::string* ClientIncidentResponse::mutable_token() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentResponse.token) + return _internal_mutable_token(); +} +inline const std::string& ClientIncidentResponse::_internal_token() const { + return token_.GetNoArena(); +} +inline void ClientIncidentResponse::_internal_set_token(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientIncidentResponse::set_token(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + token_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientIncidentResponse.token) +} +inline void ClientIncidentResponse::set_token(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentResponse.token) +} +inline void ClientIncidentResponse::set_token(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentResponse.token) +} +inline std::string* ClientIncidentResponse::_internal_mutable_token() { + _has_bits_[0] |= 0x00000001u; + return token_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientIncidentResponse::release_token() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientIncidentResponse.token) + if (!_internal_has_token()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return token_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientIncidentResponse::set_allocated_token(std::string* token) { + if (token != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + token_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), token); + // @@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 = (_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() { + download_requested_ = false; + _has_bits_[0] &= ~0x00000002u; +} +inline bool ClientIncidentResponse::_internal_download_requested() const { + return 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) { + _has_bits_[0] |= 0x00000002u; + 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 environment_requests_.size(); +} +inline int ClientIncidentResponse::environment_requests_size() const { + return _internal_environment_requests_size(); +} +inline void ClientIncidentResponse::clear_environment_requests() { + 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 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 &environment_requests_; +} +inline const ::safe_browsing::ClientIncidentResponse_EnvironmentRequest& ClientIncidentResponse::_internal_environment_requests(int index) const { + return 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 environment_requests_.Add(); +} +inline ::safe_browsing::ClientIncidentResponse_EnvironmentRequest* ClientIncidentResponse::add_environment_requests() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentResponse.environment_requests) + return _internal_add_environment_requests(); +} +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 environment_requests_; +} + +// ------------------------------------------------------------------- + +// DownloadMetadata + +// optional uint32 download_id = 1; +inline bool DownloadMetadata::_internal_has_download_id() const { + bool value = (_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() { + download_id_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 DownloadMetadata::_internal_download_id() const { + return download_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 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(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _has_bits_[0] |= 0x00000002u; + download_id_ = value; +} +inline void DownloadMetadata::set_download_id(::PROTOBUF_NAMESPACE_ID::uint32 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 = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || download_ != nullptr); + return value; +} +inline bool DownloadMetadata::has_download() const { + return _internal_has_download(); +} +inline void DownloadMetadata::clear_download() { + if (download_ != nullptr) download_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::safe_browsing::ClientIncidentReport_DownloadDetails& DownloadMetadata::_internal_download() const { + const ::safe_browsing::ClientIncidentReport_DownloadDetails* p = 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 ::safe_browsing::ClientIncidentReport_DownloadDetails* DownloadMetadata::release_download() { + // @@protoc_insertion_point(field_release:safe_browsing.DownloadMetadata.download) + _has_bits_[0] &= ~0x00000001u; + ::safe_browsing::ClientIncidentReport_DownloadDetails* temp = download_; + download_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientIncidentReport_DownloadDetails* DownloadMetadata::_internal_mutable_download() { + _has_bits_[0] |= 0x00000001u; + if (download_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientIncidentReport_DownloadDetails>(GetArenaNoVirtual()); + download_ = p; + } + return download_; +} +inline ::safe_browsing::ClientIncidentReport_DownloadDetails* DownloadMetadata::mutable_download() { + // @@protoc_insertion_point(field_mutable:safe_browsing.DownloadMetadata.download) + return _internal_mutable_download(); +} +inline void DownloadMetadata::set_allocated_download(::safe_browsing::ClientIncidentReport_DownloadDetails* download) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete download_; + } + if (download) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + download = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, download, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest_HTTPHeader::has_name() const { + return _internal_has_name(); +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::clear_name() { + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPHeader::mutable_name() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name) + return _internal_mutable_name(); +} +inline const std::string& ClientSafeBrowsingReportRequest_HTTPHeader::_internal_name() const { + return name_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name) +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name) +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_name(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPHeader::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPHeader::release_name() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest_HTTPHeader::has_value() const { + return _internal_has_value(); +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::clear_value() { + value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_value(const std::string& value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPHeader::mutable_value() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value) + return _internal_mutable_value(); +} +inline const std::string& ClientSafeBrowsingReportRequest_HTTPHeader::_internal_value() const { + return value_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::_internal_set_value(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_value(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + value_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value) +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_value(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value) +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_value(const void* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPHeader::_internal_mutable_value() { + _has_bits_[0] |= 0x00000002u; + return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPHeader::release_value() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value) + if (!_internal_has_value()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return value_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_allocated_value(std::string* value) { + if (value != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@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 = (_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() { + verb_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_verb(const std::string& value) { + _internal_set_verb(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::mutable_verb() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb) + return _internal_mutable_verb(); +} +inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_verb() const { + return verb_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_set_verb(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + verb_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_verb(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + verb_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb) +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_verb(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + verb_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb) +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_verb(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + verb_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_mutable_verb() { + _has_bits_[0] |= 0x00000001u; + return verb_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return verb_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_allocated_verb(std::string* verb) { + if (verb != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + verb_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), verb); + // @@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 = (_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() { + uri_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_uri(const std::string& value) { + _internal_set_uri(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::mutable_uri() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri) + return _internal_mutable_uri(); +} +inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_uri() const { + return uri_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_set_uri(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + uri_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_uri(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + uri_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri) +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_uri(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + uri_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri) +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_uri(const void* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + uri_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_mutable_uri() { + _has_bits_[0] |= 0x00000002u; + return uri_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return uri_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_allocated_uri(std::string* uri) { + if (uri != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + uri_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri); + // @@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 = (_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() { + version_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_version(const std::string& value) { + _internal_set_version(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::mutable_version() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version) + return _internal_mutable_version(); +} +inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_version() const { + return version_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_set_version(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_version(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + version_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version) +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_version(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version) +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_version(const void* value, size_t size) { + _has_bits_[0] |= 0x00000004u; + version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::_internal_mutable_version() { + _has_bits_[0] |= 0x00000004u; + return version_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000004u; + return version_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_allocated_version(std::string* version) { + if (version != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + version_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), version); + // @@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 = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || firstline_ != nullptr); + return value; +} +inline bool ClientSafeBrowsingReportRequest_HTTPRequest::has_firstline() const { + return _internal_has_firstline(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_firstline() { + if (firstline_ != nullptr) firstline_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& ClientSafeBrowsingReportRequest_HTTPRequest::_internal_firstline() const { + const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* p = 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 ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* ClientSafeBrowsingReportRequest_HTTPRequest::release_firstline() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.firstline) + _has_bits_[0] &= ~0x00000004u; + ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* temp = firstline_; + firstline_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* ClientSafeBrowsingReportRequest_HTTPRequest::_internal_mutable_firstline() { + _has_bits_[0] |= 0x00000004u; + if (firstline_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine>(GetArenaNoVirtual()); + firstline_ = p; + } + return firstline_; +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* ClientSafeBrowsingReportRequest_HTTPRequest::mutable_firstline() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.firstline) + return _internal_mutable_firstline(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_allocated_firstline(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* firstline) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete firstline_; + } + if (firstline) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + firstline = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, firstline, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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 headers_.size(); +} +inline int ClientSafeBrowsingReportRequest_HTTPRequest::headers_size() const { + return _internal_headers_size(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_headers() { + headers_.Clear(); +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPRequest::mutable_headers(int index) { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.headers) + return 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 &headers_; +} +inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& ClientSafeBrowsingReportRequest_HTTPRequest::_internal_headers(int index) const { + return 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 headers_.Add(); +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPRequest::add_headers() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.headers) + return _internal_add_headers(); +} +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 headers_; +} + +// optional bytes body = 3; +inline bool ClientSafeBrowsingReportRequest_HTTPRequest::_internal_has_body() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest_HTTPRequest::has_body() const { + return _internal_has_body(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_body() { + body_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_body(const std::string& value) { + _internal_set_body(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest::mutable_body() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body) + return _internal_mutable_body(); +} +inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest::_internal_body() const { + return body_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::_internal_set_body(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + body_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_body(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + body_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body) +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_body(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + body_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body) +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_body(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + body_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest::_internal_mutable_body() { + _has_bits_[0] |= 0x00000001u; + return body_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest::release_body() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body) + if (!_internal_has_body()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return body_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_allocated_body(std::string* body) { + if (body != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + body_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), body); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest_HTTPRequest::has_bodydigest() const { + return _internal_has_bodydigest(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_bodydigest() { + bodydigest_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_bodydigest(const std::string& value) { + _internal_set_bodydigest(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest::mutable_bodydigest() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest) + return _internal_mutable_bodydigest(); +} +inline const std::string& ClientSafeBrowsingReportRequest_HTTPRequest::_internal_bodydigest() const { + return bodydigest_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::_internal_set_bodydigest(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + bodydigest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_bodydigest(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + bodydigest_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest) +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_bodydigest(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + bodydigest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest) +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_bodydigest(const void* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + bodydigest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest::_internal_mutable_bodydigest() { + _has_bits_[0] |= 0x00000002u; + return bodydigest_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPRequest::release_bodydigest() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest) + if (!_internal_has_bodydigest()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return bodydigest_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_allocated_bodydigest(std::string* bodydigest) { + if (bodydigest != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + bodydigest_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bodydigest); + // @@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 = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest_HTTPRequest::has_bodylength() const { + return _internal_has_bodylength(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_bodylength() { + bodylength_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientSafeBrowsingReportRequest_HTTPRequest::_internal_bodylength() const { + return bodylength_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientSafeBrowsingReportRequest_HTTPRequest::bodylength() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodylength) + return _internal_bodylength(); +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::_internal_set_bodylength(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000008u; + bodylength_ = value; +} +inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_bodylength(::PROTOBUF_NAMESPACE_ID::int32 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 = (_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() { + code_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_code() const { + return code_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000004u; + code_ = value; +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_code(::PROTOBUF_NAMESPACE_ID::int32 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 = (_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() { + message_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_message(const std::string& value) { + _internal_set_message(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.message) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::mutable_message() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.message) + return _internal_mutable_message(); +} +inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_message() const { + return message_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_set_message(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_message(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + message_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.message) +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_message(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.message) +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_message(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.message) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_mutable_message() { + _has_bits_[0] |= 0x00000001u; + return message_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return message_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_allocated_message(std::string* message) { + if (message != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + message_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message); + // @@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 = (_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() { + version_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_version(const std::string& value) { + _internal_set_version(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::mutable_version() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version) + return _internal_mutable_version(); +} +inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_version() const { + return version_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_set_version(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_version(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + version_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version) +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_version(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version) +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_version(const void* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::_internal_mutable_version() { + _has_bits_[0] |= 0x00000002u; + return version_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return version_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_allocated_version(std::string* version) { + if (version != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + version_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), version); + // @@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 = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || firstline_ != nullptr); + return value; +} +inline bool ClientSafeBrowsingReportRequest_HTTPResponse::has_firstline() const { + return _internal_has_firstline(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_firstline() { + if (firstline_ != nullptr) firstline_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& ClientSafeBrowsingReportRequest_HTTPResponse::_internal_firstline() const { + const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* p = 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 ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* ClientSafeBrowsingReportRequest_HTTPResponse::release_firstline() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.firstline) + _has_bits_[0] &= ~0x00000008u; + ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* temp = firstline_; + firstline_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* ClientSafeBrowsingReportRequest_HTTPResponse::_internal_mutable_firstline() { + _has_bits_[0] |= 0x00000008u; + if (firstline_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine>(GetArenaNoVirtual()); + firstline_ = p; + } + return firstline_; +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_firstline() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.firstline) + return _internal_mutable_firstline(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_allocated_firstline(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* firstline) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete firstline_; + } + if (firstline) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + firstline = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, firstline, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + 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 headers_.size(); +} +inline int ClientSafeBrowsingReportRequest_HTTPResponse::headers_size() const { + return _internal_headers_size(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_headers() { + headers_.Clear(); +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_headers(int index) { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.headers) + return 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 &headers_; +} +inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& ClientSafeBrowsingReportRequest_HTTPResponse::_internal_headers(int index) const { + return 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 headers_.Add(); +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPResponse::add_headers() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.headers) + return _internal_add_headers(); +} +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 headers_; +} + +// optional bytes body = 3; +inline bool ClientSafeBrowsingReportRequest_HTTPResponse::_internal_has_body() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest_HTTPResponse::has_body() const { + return _internal_has_body(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_body() { + body_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_body(const std::string& value) { + _internal_set_body(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_body() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body) + return _internal_mutable_body(); +} +inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse::_internal_body() const { + return body_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::_internal_set_body(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + body_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_body(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + body_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body) +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_body(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + body_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body) +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_body(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + body_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::_internal_mutable_body() { + _has_bits_[0] |= 0x00000001u; + return body_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::release_body() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body) + if (!_internal_has_body()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return body_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_allocated_body(std::string* body) { + if (body != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + body_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), body); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest_HTTPResponse::has_bodydigest() const { + return _internal_has_bodydigest(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_bodydigest() { + bodydigest_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_bodydigest(const std::string& value) { + _internal_set_bodydigest(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_bodydigest() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest) + return _internal_mutable_bodydigest(); +} +inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse::_internal_bodydigest() const { + return bodydigest_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::_internal_set_bodydigest(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + bodydigest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_bodydigest(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + bodydigest_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest) +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_bodydigest(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + bodydigest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest) +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_bodydigest(const void* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + bodydigest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::_internal_mutable_bodydigest() { + _has_bits_[0] |= 0x00000002u; + return bodydigest_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::release_bodydigest() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest) + if (!_internal_has_bodydigest()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return bodydigest_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_allocated_bodydigest(std::string* bodydigest) { + if (bodydigest != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + bodydigest_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bodydigest); + // @@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 = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest_HTTPResponse::has_bodylength() const { + return _internal_has_bodylength(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_bodylength() { + bodylength_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientSafeBrowsingReportRequest_HTTPResponse::_internal_bodylength() const { + return bodylength_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientSafeBrowsingReportRequest_HTTPResponse::bodylength() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodylength) + return _internal_bodylength(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::_internal_set_bodylength(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000010u; + bodylength_ = value; +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_bodylength(::PROTOBUF_NAMESPACE_ID::int32 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 = (_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() { + remote_ip_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_remote_ip(const std::string& value) { + _internal_set_remote_ip(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_remote_ip() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip) + return _internal_mutable_remote_ip(); +} +inline const std::string& ClientSafeBrowsingReportRequest_HTTPResponse::_internal_remote_ip() const { + return remote_ip_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::_internal_set_remote_ip(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + remote_ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_remote_ip(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + remote_ip_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip) +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_remote_ip(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + remote_ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip) +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_remote_ip(const void* value, size_t size) { + _has_bits_[0] |= 0x00000004u; + remote_ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip) +} +inline std::string* ClientSafeBrowsingReportRequest_HTTPResponse::_internal_mutable_remote_ip() { + _has_bits_[0] |= 0x00000004u; + return remote_ip_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000004u; + return remote_ip_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_allocated_remote_ip(std::string* remote_ip) { + if (remote_ip != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + remote_ip_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), remote_ip); + // @@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 = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest_Resource::has_id() const { + return _internal_has_id(); +} +inline void ClientSafeBrowsingReportRequest_Resource::clear_id() { + id_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientSafeBrowsingReportRequest_Resource::_internal_id() const { + return id_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientSafeBrowsingReportRequest_Resource::id() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.id) + return _internal_id(); +} +inline void ClientSafeBrowsingReportRequest_Resource::_internal_set_id(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000010u; + id_ = value; +} +inline void ClientSafeBrowsingReportRequest_Resource::set_id(::PROTOBUF_NAMESPACE_ID::int32 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest_Resource::has_url() const { + return _internal_has_url(); +} +inline void ClientSafeBrowsingReportRequest_Resource::clear_url() { + url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_Resource::set_url(const std::string& value) { + _internal_set_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url) +} +inline std::string* ClientSafeBrowsingReportRequest_Resource::mutable_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url) + return _internal_mutable_url(); +} +inline const std::string& ClientSafeBrowsingReportRequest_Resource::_internal_url() const { + return url_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_Resource::_internal_set_url(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_Resource::set_url(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url) +} +inline void ClientSafeBrowsingReportRequest_Resource::set_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url) +} +inline void ClientSafeBrowsingReportRequest_Resource::set_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url) +} +inline std::string* ClientSafeBrowsingReportRequest_Resource::_internal_mutable_url() { + _has_bits_[0] |= 0x00000001u; + return url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientSafeBrowsingReportRequest_Resource::release_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url) + if (!_internal_has_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_Resource::set_allocated_url(std::string* url) { + if (url != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url); + // @@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 = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || request_ != nullptr); + return value; +} +inline bool ClientSafeBrowsingReportRequest_Resource::has_request() const { + return _internal_has_request(); +} +inline void ClientSafeBrowsingReportRequest_Resource::clear_request() { + if (request_ != nullptr) request_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest& ClientSafeBrowsingReportRequest_Resource::_internal_request() const { + const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* p = 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 ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* ClientSafeBrowsingReportRequest_Resource::release_request() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.Resource.request) + _has_bits_[0] &= ~0x00000004u; + ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* temp = request_; + request_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* ClientSafeBrowsingReportRequest_Resource::_internal_mutable_request() { + _has_bits_[0] |= 0x00000004u; + if (request_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest>(GetArenaNoVirtual()); + request_ = p; + } + return request_; +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* ClientSafeBrowsingReportRequest_Resource::mutable_request() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.Resource.request) + return _internal_mutable_request(); +} +inline void ClientSafeBrowsingReportRequest_Resource::set_allocated_request(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* request) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete request_; + } + if (request) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, request, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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 = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || response_ != nullptr); + return value; +} +inline bool ClientSafeBrowsingReportRequest_Resource::has_response() const { + return _internal_has_response(); +} +inline void ClientSafeBrowsingReportRequest_Resource::clear_response() { + if (response_ != nullptr) response_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse& ClientSafeBrowsingReportRequest_Resource::_internal_response() const { + const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* p = 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 ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* ClientSafeBrowsingReportRequest_Resource::release_response() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.Resource.response) + _has_bits_[0] &= ~0x00000008u; + ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* temp = response_; + response_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* ClientSafeBrowsingReportRequest_Resource::_internal_mutable_response() { + _has_bits_[0] |= 0x00000008u; + if (response_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse>(GetArenaNoVirtual()); + response_ = p; + } + return response_; +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* ClientSafeBrowsingReportRequest_Resource::mutable_response() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.Resource.response) + return _internal_mutable_response(); +} +inline void ClientSafeBrowsingReportRequest_Resource::set_allocated_response(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* response) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete response_; + } + if (response) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, response, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + 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 = (_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() { + parent_id_ = 0; + _has_bits_[0] &= ~0x00000020u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientSafeBrowsingReportRequest_Resource::_internal_parent_id() const { + return parent_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000020u; + parent_id_ = value; +} +inline void ClientSafeBrowsingReportRequest_Resource::set_parent_id(::PROTOBUF_NAMESPACE_ID::int32 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 child_ids_.size(); +} +inline int ClientSafeBrowsingReportRequest_Resource::child_ids_size() const { + return _internal_child_ids_size(); +} +inline void ClientSafeBrowsingReportRequest_Resource::clear_child_ids() { + child_ids_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ClientSafeBrowsingReportRequest_Resource::_internal_child_ids(int index) const { + return child_ids_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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, ::PROTOBUF_NAMESPACE_ID::int32 value) { + child_ids_.Set(index, value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.Resource.child_ids) +} +inline void ClientSafeBrowsingReportRequest_Resource::_internal_add_child_ids(::PROTOBUF_NAMESPACE_ID::int32 value) { + child_ids_.Add(value); +} +inline void ClientSafeBrowsingReportRequest_Resource::add_child_ids(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_add_child_ids(value); + // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.Resource.child_ids) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +ClientSafeBrowsingReportRequest_Resource::_internal_child_ids() const { + return child_ids_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +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< ::PROTOBUF_NAMESPACE_ID::int32 >* +ClientSafeBrowsingReportRequest_Resource::_internal_mutable_child_ids() { + return &child_ids_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +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 = (_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() { + tag_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_Resource::set_tag_name(const std::string& value) { + _internal_set_tag_name(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name) +} +inline std::string* ClientSafeBrowsingReportRequest_Resource::mutable_tag_name() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name) + return _internal_mutable_tag_name(); +} +inline const std::string& ClientSafeBrowsingReportRequest_Resource::_internal_tag_name() const { + return tag_name_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_Resource::_internal_set_tag_name(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + tag_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_Resource::set_tag_name(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + tag_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name) +} +inline void ClientSafeBrowsingReportRequest_Resource::set_tag_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + tag_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name) +} +inline void ClientSafeBrowsingReportRequest_Resource::set_tag_name(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + tag_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name) +} +inline std::string* ClientSafeBrowsingReportRequest_Resource::_internal_mutable_tag_name() { + _has_bits_[0] |= 0x00000002u; + return tag_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000002u; + return tag_name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_Resource::set_allocated_tag_name(std::string* tag_name) { + if (tag_name != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + tag_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tag_name); + // @@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 = (_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() { + client_version_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::set_client_version(const std::string& value) { + _internal_set_client_version(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.client_version) +} +inline std::string* ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::mutable_client_version() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.client_version) + return _internal_mutable_client_version(); +} +inline const std::string& ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_client_version() const { + return client_version_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_set_client_version(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + client_version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::set_client_version(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + client_version_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.client_version) +} +inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::set_client_version(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + client_version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.client_version) +} +inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::set_client_version(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + client_version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.SafeBrowsingClientProperties.client_version) +} +inline std::string* ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_mutable_client_version() { + _has_bits_[0] |= 0x00000001u; + return client_version_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +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; + } + _has_bits_[0] &= ~0x00000001u; + return client_version_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::set_allocated_client_version(std::string* client_version) { + if (client_version != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + client_version_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_version); + // @@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 = (_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() { + google_play_services_version_ = PROTOBUF_LONGLONG(0); + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_google_play_services_version() const { + return google_play_services_version_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 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(::PROTOBUF_NAMESPACE_ID::int64 value) { + _has_bits_[0] |= 0x00000002u; + google_play_services_version_ = value; +} +inline void ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::set_google_play_services_version(::PROTOBUF_NAMESPACE_ID::int64 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 = (_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() { + is_instant_apps_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_is_instant_apps() const { + return 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) { + _has_bits_[0] |= 0x00000004u; + 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 = (_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() { + url_api_type_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties::_internal_url_api_type() const { + return static_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingUrlApiType >(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)); + _has_bits_[0] |= 0x00000008u; + 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 = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest::has_type() const { + return _internal_has_type(); +} +inline void ClientSafeBrowsingReportRequest::clear_type() { + type_ = 0; + _has_bits_[0] &= ~0x00000040u; +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::_internal_type() const { + return static_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_ReportType >(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)); + _has_bits_[0] |= 0x00000040u; + 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 = (_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() { + download_verdict_ = 0; + _has_bits_[0] &= ~0x00000800u; +} +inline ::safe_browsing::ClientDownloadResponse_Verdict ClientSafeBrowsingReportRequest::_internal_download_verdict() const { + return static_cast< ::safe_browsing::ClientDownloadResponse_Verdict >(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)); + _has_bits_[0] |= 0x00000800u; + 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest::has_url() const { + return _internal_has_url(); +} +inline void ClientSafeBrowsingReportRequest::clear_url() { + url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ClientSafeBrowsingReportRequest::url() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.url) + return _internal_url(); +} +inline void ClientSafeBrowsingReportRequest::set_url(const std::string& value) { + _internal_set_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.url) +} +inline std::string* ClientSafeBrowsingReportRequest::mutable_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.url) + return _internal_mutable_url(); +} +inline const std::string& ClientSafeBrowsingReportRequest::_internal_url() const { + return url_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest::_internal_set_url(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest::set_url(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.url) +} +inline void ClientSafeBrowsingReportRequest::set_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.url) +} +inline void ClientSafeBrowsingReportRequest::set_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.url) +} +inline std::string* ClientSafeBrowsingReportRequest::_internal_mutable_url() { + _has_bits_[0] |= 0x00000001u; + return url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientSafeBrowsingReportRequest::release_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.url) + if (!_internal_has_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest::set_allocated_url(std::string* url) { + if (url != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), url); + // @@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 = (_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() { + page_url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest::set_page_url(const std::string& value) { + _internal_set_page_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.page_url) +} +inline std::string* ClientSafeBrowsingReportRequest::mutable_page_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.page_url) + return _internal_mutable_page_url(); +} +inline const std::string& ClientSafeBrowsingReportRequest::_internal_page_url() const { + return page_url_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest::_internal_set_page_url(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + page_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest::set_page_url(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + page_url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.page_url) +} +inline void ClientSafeBrowsingReportRequest::set_page_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + page_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.page_url) +} +inline void ClientSafeBrowsingReportRequest::set_page_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + page_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.page_url) +} +inline std::string* ClientSafeBrowsingReportRequest::_internal_mutable_page_url() { + _has_bits_[0] |= 0x00000002u; + return page_url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientSafeBrowsingReportRequest::release_page_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.page_url) + if (!_internal_has_page_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return page_url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest::set_allocated_page_url(std::string* page_url) { + if (page_url != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + page_url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), page_url); + // @@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 = (_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() { + referrer_url_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest::set_referrer_url(const std::string& value) { + _internal_set_referrer_url(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url) +} +inline std::string* ClientSafeBrowsingReportRequest::mutable_referrer_url() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url) + return _internal_mutable_referrer_url(); +} +inline const std::string& ClientSafeBrowsingReportRequest::_internal_referrer_url() const { + return referrer_url_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest::_internal_set_referrer_url(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + referrer_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest::set_referrer_url(std::string&& value) { + _has_bits_[0] |= 0x00000004u; + referrer_url_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url) +} +inline void ClientSafeBrowsingReportRequest::set_referrer_url(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000004u; + referrer_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url) +} +inline void ClientSafeBrowsingReportRequest::set_referrer_url(const char* value, size_t size) { + _has_bits_[0] |= 0x00000004u; + referrer_url_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url) +} +inline std::string* ClientSafeBrowsingReportRequest::_internal_mutable_referrer_url() { + _has_bits_[0] |= 0x00000004u; + return referrer_url_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientSafeBrowsingReportRequest::release_referrer_url() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url) + if (!_internal_has_referrer_url()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + return referrer_url_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest::set_allocated_referrer_url(std::string* referrer_url) { + if (referrer_url != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + referrer_url_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), referrer_url); + // @@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 resources_.size(); +} +inline int ClientSafeBrowsingReportRequest::resources_size() const { + return _internal_resources_size(); +} +inline void ClientSafeBrowsingReportRequest::clear_resources() { + resources_.Clear(); +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* ClientSafeBrowsingReportRequest::mutable_resources(int index) { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.resources) + return 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 &resources_; +} +inline const ::safe_browsing::ClientSafeBrowsingReportRequest_Resource& ClientSafeBrowsingReportRequest::_internal_resources(int index) const { + return 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 resources_.Add(); +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* ClientSafeBrowsingReportRequest::add_resources() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.resources) + return _internal_add_resources(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource >& +ClientSafeBrowsingReportRequest::resources() const { + // @@protoc_insertion_point(field_list:safe_browsing.ClientSafeBrowsingReportRequest.resources) + return resources_; +} + +// repeated .safe_browsing.HTMLElement dom = 16; +inline int ClientSafeBrowsingReportRequest::_internal_dom_size() const { + return dom_.size(); +} +inline int ClientSafeBrowsingReportRequest::dom_size() const { + return _internal_dom_size(); +} +inline void ClientSafeBrowsingReportRequest::clear_dom() { + dom_.Clear(); +} +inline ::safe_browsing::HTMLElement* ClientSafeBrowsingReportRequest::mutable_dom(int index) { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.dom) + return 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 &dom_; +} +inline const ::safe_browsing::HTMLElement& ClientSafeBrowsingReportRequest::_internal_dom(int index) const { + return 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 dom_.Add(); +} +inline ::safe_browsing::HTMLElement* ClientSafeBrowsingReportRequest::add_dom() { + // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.dom) + return _internal_add_dom(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::HTMLElement >& +ClientSafeBrowsingReportRequest::dom() const { + // @@protoc_insertion_point(field_list:safe_browsing.ClientSafeBrowsingReportRequest.dom) + return dom_; +} + +// optional bool complete = 5; +inline bool ClientSafeBrowsingReportRequest::_internal_has_complete() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest::has_complete() const { + return _internal_has_complete(); +} +inline void ClientSafeBrowsingReportRequest::clear_complete() { + complete_ = false; + _has_bits_[0] &= ~0x00000080u; +} +inline bool ClientSafeBrowsingReportRequest::_internal_complete() const { + return 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) { + _has_bits_[0] |= 0x00000080u; + 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 client_asn_.size(); +} +inline int ClientSafeBrowsingReportRequest::client_asn_size() const { + return _internal_client_asn_size(); +} +inline void ClientSafeBrowsingReportRequest::clear_client_asn() { + client_asn_.Clear(); +} +inline std::string* ClientSafeBrowsingReportRequest::add_client_asn() { + // @@protoc_insertion_point(field_add_mutable:safe_browsing.ClientSafeBrowsingReportRequest.client_asn) + return _internal_add_client_asn(); +} +inline const std::string& ClientSafeBrowsingReportRequest::_internal_client_asn(int index) const { + return 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 client_asn_.Mutable(index); +} +inline void ClientSafeBrowsingReportRequest::set_client_asn(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.client_asn) + client_asn_.Mutable(index)->assign(value); +} +inline void ClientSafeBrowsingReportRequest::set_client_asn(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.client_asn) + client_asn_.Mutable(index)->assign(std::move(value)); +} +inline void ClientSafeBrowsingReportRequest::set_client_asn(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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) { + 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 client_asn_.Add(); +} +inline void ClientSafeBrowsingReportRequest::add_client_asn(const std::string& value) { + client_asn_.Add()->assign(value); + // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.client_asn) +} +inline void ClientSafeBrowsingReportRequest::add_client_asn(std::string&& value) { + 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); + 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) { + 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 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 &client_asn_; +} + +// optional string client_country = 7; +inline bool ClientSafeBrowsingReportRequest::_internal_has_client_country() const { + bool value = (_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() { + client_country_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ClientSafeBrowsingReportRequest::set_client_country(const std::string& value) { + _internal_set_client_country(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.client_country) +} +inline std::string* ClientSafeBrowsingReportRequest::mutable_client_country() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.client_country) + return _internal_mutable_client_country(); +} +inline const std::string& ClientSafeBrowsingReportRequest::_internal_client_country() const { + return client_country_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest::_internal_set_client_country(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + client_country_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest::set_client_country(std::string&& value) { + _has_bits_[0] |= 0x00000008u; + client_country_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.client_country) +} +inline void ClientSafeBrowsingReportRequest::set_client_country(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000008u; + client_country_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.client_country) +} +inline void ClientSafeBrowsingReportRequest::set_client_country(const char* value, size_t size) { + _has_bits_[0] |= 0x00000008u; + client_country_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.client_country) +} +inline std::string* ClientSafeBrowsingReportRequest::_internal_mutable_client_country() { + _has_bits_[0] |= 0x00000008u; + return client_country_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientSafeBrowsingReportRequest::release_client_country() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.client_country) + if (!_internal_has_client_country()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + return client_country_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest::set_allocated_client_country(std::string* client_country) { + if (client_country != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + client_country_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_country); + // @@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 = (_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() { + did_proceed_ = false; + _has_bits_[0] &= ~0x00000100u; +} +inline bool ClientSafeBrowsingReportRequest::_internal_did_proceed() const { + return 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) { + _has_bits_[0] |= 0x00000100u; + 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 = (_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() { + repeat_visit_ = false; + _has_bits_[0] &= ~0x00000200u; +} +inline bool ClientSafeBrowsingReportRequest::_internal_repeat_visit() const { + return 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) { + _has_bits_[0] |= 0x00000200u; + 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 = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ClientSafeBrowsingReportRequest::has_token() const { + return _internal_has_token(); +} +inline void ClientSafeBrowsingReportRequest::clear_token() { + token_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _has_bits_[0] &= ~0x00000010u; +} +inline const std::string& ClientSafeBrowsingReportRequest::token() const { + // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.token) + return _internal_token(); +} +inline void ClientSafeBrowsingReportRequest::set_token(const std::string& value) { + _internal_set_token(value); + // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.token) +} +inline std::string* ClientSafeBrowsingReportRequest::mutable_token() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.token) + return _internal_mutable_token(); +} +inline const std::string& ClientSafeBrowsingReportRequest::_internal_token() const { + return token_.GetNoArena(); +} +inline void ClientSafeBrowsingReportRequest::_internal_set_token(const std::string& value) { + _has_bits_[0] |= 0x00000010u; + token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ClientSafeBrowsingReportRequest::set_token(std::string&& value) { + _has_bits_[0] |= 0x00000010u; + token_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ClientSafeBrowsingReportRequest.token) +} +inline void ClientSafeBrowsingReportRequest::set_token(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000010u; + token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.token) +} +inline void ClientSafeBrowsingReportRequest::set_token(const void* value, size_t size) { + _has_bits_[0] |= 0x00000010u; + token_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.token) +} +inline std::string* ClientSafeBrowsingReportRequest::_internal_mutable_token() { + _has_bits_[0] |= 0x00000010u; + return token_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ClientSafeBrowsingReportRequest::release_token() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.token) + if (!_internal_has_token()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000010u; + return token_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ClientSafeBrowsingReportRequest::set_allocated_token(std::string* token) { + if (token != nullptr) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + token_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), token); + // @@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 = (_has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || client_properties_ != nullptr); + return value; +} +inline bool ClientSafeBrowsingReportRequest::has_client_properties() const { + return _internal_has_client_properties(); +} +inline void ClientSafeBrowsingReportRequest::clear_client_properties() { + if (client_properties_ != nullptr) client_properties_->Clear(); + _has_bits_[0] &= ~0x00000020u; +} +inline const ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties& ClientSafeBrowsingReportRequest::_internal_client_properties() const { + const ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* p = 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 ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* ClientSafeBrowsingReportRequest::release_client_properties() { + // @@protoc_insertion_point(field_release:safe_browsing.ClientSafeBrowsingReportRequest.client_properties) + _has_bits_[0] &= ~0x00000020u; + ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* temp = client_properties_; + client_properties_ = nullptr; + return temp; +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* ClientSafeBrowsingReportRequest::_internal_mutable_client_properties() { + _has_bits_[0] |= 0x00000020u; + if (client_properties_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties>(GetArenaNoVirtual()); + client_properties_ = p; + } + return client_properties_; +} +inline ::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* ClientSafeBrowsingReportRequest::mutable_client_properties() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.client_properties) + return _internal_mutable_client_properties(); +} +inline void ClientSafeBrowsingReportRequest::set_allocated_client_properties(::safe_browsing::ClientSafeBrowsingReportRequest_SafeBrowsingClientProperties* client_properties) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete client_properties_; + } + if (client_properties) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + client_properties = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, client_properties, submessage_arena); + } + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + 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 = (_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() { + show_download_in_folder_ = false; + _has_bits_[0] &= ~0x00000400u; +} +inline bool ClientSafeBrowsingReportRequest::_internal_show_download_in_folder() const { + return 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) { + _has_bits_[0] |= 0x00000400u; + 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool HTMLElement_Attribute::has_name() const { + return _internal_has_name(); +} +inline void HTMLElement_Attribute::clear_name() { + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void HTMLElement_Attribute::set_name(const std::string& value) { + _internal_set_name(value); + // @@protoc_insertion_point(field_set:safe_browsing.HTMLElement.Attribute.name) +} +inline std::string* HTMLElement_Attribute::mutable_name() { + // @@protoc_insertion_point(field_mutable:safe_browsing.HTMLElement.Attribute.name) + return _internal_mutable_name(); +} +inline const std::string& HTMLElement_Attribute::_internal_name() const { + return name_.GetNoArena(); +} +inline void HTMLElement_Attribute::_internal_set_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void HTMLElement_Attribute::set_name(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.HTMLElement.Attribute.name) +} +inline void HTMLElement_Attribute::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.HTMLElement.Attribute.name) +} +inline void HTMLElement_Attribute::set_name(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.HTMLElement.Attribute.name) +} +inline std::string* HTMLElement_Attribute::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HTMLElement_Attribute::release_name() { + // @@protoc_insertion_point(field_release:safe_browsing.HTMLElement.Attribute.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HTMLElement_Attribute::set_allocated_name(std::string* name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool HTMLElement_Attribute::has_value() const { + return _internal_has_value(); +} +inline void HTMLElement_Attribute::clear_value() { + value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void HTMLElement_Attribute::set_value(const std::string& value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:safe_browsing.HTMLElement.Attribute.value) +} +inline std::string* HTMLElement_Attribute::mutable_value() { + // @@protoc_insertion_point(field_mutable:safe_browsing.HTMLElement.Attribute.value) + return _internal_mutable_value(); +} +inline const std::string& HTMLElement_Attribute::_internal_value() const { + return value_.GetNoArena(); +} +inline void HTMLElement_Attribute::_internal_set_value(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void HTMLElement_Attribute::set_value(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + value_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.HTMLElement.Attribute.value) +} +inline void HTMLElement_Attribute::set_value(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.HTMLElement.Attribute.value) +} +inline void HTMLElement_Attribute::set_value(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.HTMLElement.Attribute.value) +} +inline std::string* HTMLElement_Attribute::_internal_mutable_value() { + _has_bits_[0] |= 0x00000002u; + return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HTMLElement_Attribute::release_value() { + // @@protoc_insertion_point(field_release:safe_browsing.HTMLElement.Attribute.value) + if (!_internal_has_value()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return value_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HTMLElement_Attribute::set_allocated_value(std::string* value) { + if (value != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool HTMLElement::has_id() const { + return _internal_has_id(); +} +inline void HTMLElement::clear_id() { + id_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 HTMLElement::_internal_id() const { + return id_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 HTMLElement::id() const { + // @@protoc_insertion_point(field_get:safe_browsing.HTMLElement.id) + return _internal_id(); +} +inline void HTMLElement::_internal_set_id(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000002u; + id_ = value; +} +inline void HTMLElement::set_id(::PROTOBUF_NAMESPACE_ID::int32 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool HTMLElement::has_tag() const { + return _internal_has_tag(); +} +inline void HTMLElement::clear_tag() { + tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& HTMLElement::tag() const { + // @@protoc_insertion_point(field_get:safe_browsing.HTMLElement.tag) + return _internal_tag(); +} +inline void HTMLElement::set_tag(const std::string& value) { + _internal_set_tag(value); + // @@protoc_insertion_point(field_set:safe_browsing.HTMLElement.tag) +} +inline std::string* HTMLElement::mutable_tag() { + // @@protoc_insertion_point(field_mutable:safe_browsing.HTMLElement.tag) + return _internal_mutable_tag(); +} +inline const std::string& HTMLElement::_internal_tag() const { + return tag_.GetNoArena(); +} +inline void HTMLElement::_internal_set_tag(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void HTMLElement::set_tag(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + tag_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.HTMLElement.tag) +} +inline void HTMLElement::set_tag(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.HTMLElement.tag) +} +inline void HTMLElement::set_tag(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.HTMLElement.tag) +} +inline std::string* HTMLElement::_internal_mutable_tag() { + _has_bits_[0] |= 0x00000001u; + return tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HTMLElement::release_tag() { + // @@protoc_insertion_point(field_release:safe_browsing.HTMLElement.tag) + if (!_internal_has_tag()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return tag_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HTMLElement::set_allocated_tag(std::string* tag) { + if (tag != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tag); + // @@protoc_insertion_point(field_set_allocated:safe_browsing.HTMLElement.tag) +} + +// repeated int32 child_ids = 3; +inline int HTMLElement::_internal_child_ids_size() const { + return child_ids_.size(); +} +inline int HTMLElement::child_ids_size() const { + return _internal_child_ids_size(); +} +inline void HTMLElement::clear_child_ids() { + child_ids_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 HTMLElement::_internal_child_ids(int index) const { + return child_ids_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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, ::PROTOBUF_NAMESPACE_ID::int32 value) { + child_ids_.Set(index, value); + // @@protoc_insertion_point(field_set:safe_browsing.HTMLElement.child_ids) +} +inline void HTMLElement::_internal_add_child_ids(::PROTOBUF_NAMESPACE_ID::int32 value) { + child_ids_.Add(value); +} +inline void HTMLElement::add_child_ids(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_add_child_ids(value); + // @@protoc_insertion_point(field_add:safe_browsing.HTMLElement.child_ids) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +HTMLElement::_internal_child_ids() const { + return child_ids_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +HTMLElement::child_ids() const { + // @@protoc_insertion_point(field_list:safe_browsing.HTMLElement.child_ids) + return _internal_child_ids(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +HTMLElement::_internal_mutable_child_ids() { + return &child_ids_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +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 = (_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() { + resource_id_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 HTMLElement::_internal_resource_id() const { + return resource_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 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(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000004u; + resource_id_ = value; +} +inline void HTMLElement::set_resource_id(::PROTOBUF_NAMESPACE_ID::int32 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 attribute_.size(); +} +inline int HTMLElement::attribute_size() const { + return _internal_attribute_size(); +} +inline void HTMLElement::clear_attribute() { + attribute_.Clear(); +} +inline ::safe_browsing::HTMLElement_Attribute* HTMLElement::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:safe_browsing.HTMLElement.attribute) + return 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 &attribute_; +} +inline const ::safe_browsing::HTMLElement_Attribute& HTMLElement::_internal_attribute(int index) const { + return 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 attribute_.Add(); +} +inline ::safe_browsing::HTMLElement_Attribute* HTMLElement::add_attribute() { + // @@protoc_insertion_point(field_add:safe_browsing.HTMLElement.attribute) + return _internal_add_attribute(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::safe_browsing::HTMLElement_Attribute >& +HTMLElement::attribute() const { + // @@protoc_insertion_point(field_list:safe_browsing.HTMLElement.attribute) + return attribute_; +} + +// ------------------------------------------------------------------- + +// ImageData_Dimensions + +// optional int32 width = 1; +inline bool ImageData_Dimensions::_internal_has_width() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ImageData_Dimensions::has_width() const { + return _internal_has_width(); +} +inline void ImageData_Dimensions::clear_width() { + width_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ImageData_Dimensions::_internal_width() const { + return width_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ImageData_Dimensions::width() const { + // @@protoc_insertion_point(field_get:safe_browsing.ImageData.Dimensions.width) + return _internal_width(); +} +inline void ImageData_Dimensions::_internal_set_width(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000001u; + width_ = value; +} +inline void ImageData_Dimensions::set_width(::PROTOBUF_NAMESPACE_ID::int32 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 = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ImageData_Dimensions::has_height() const { + return _internal_has_height(); +} +inline void ImageData_Dimensions::clear_height() { + height_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ImageData_Dimensions::_internal_height() const { + return height_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ImageData_Dimensions::height() const { + // @@protoc_insertion_point(field_get:safe_browsing.ImageData.Dimensions.height) + return _internal_height(); +} +inline void ImageData_Dimensions::_internal_set_height(::PROTOBUF_NAMESPACE_ID::int32 value) { + _has_bits_[0] |= 0x00000002u; + height_ = value; +} +inline void ImageData_Dimensions::set_height(::PROTOBUF_NAMESPACE_ID::int32 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 = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ImageData::has_data() const { + return _internal_has_data(); +} +inline void ImageData::clear_data() { + data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ImageData::data() const { + // @@protoc_insertion_point(field_get:safe_browsing.ImageData.data) + return _internal_data(); +} +inline void ImageData::set_data(const std::string& value) { + _internal_set_data(value); + // @@protoc_insertion_point(field_set:safe_browsing.ImageData.data) +} +inline std::string* ImageData::mutable_data() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ImageData.data) + return _internal_mutable_data(); +} +inline const std::string& ImageData::_internal_data() const { + return data_.GetNoArena(); +} +inline void ImageData::_internal_set_data(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ImageData::set_data(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + data_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ImageData.data) +} +inline void ImageData::set_data(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ImageData.data) +} +inline void ImageData::set_data(const void* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ImageData.data) +} +inline std::string* ImageData::_internal_mutable_data() { + _has_bits_[0] |= 0x00000001u; + return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ImageData::release_data() { + // @@protoc_insertion_point(field_release:safe_browsing.ImageData.data) + if (!_internal_has_data()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return data_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ImageData::set_allocated_data(std::string* data) { + if (data != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data); + // @@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 = (_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() { + mime_type_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void ImageData::set_mime_type(const std::string& value) { + _internal_set_mime_type(value); + // @@protoc_insertion_point(field_set:safe_browsing.ImageData.mime_type) +} +inline std::string* ImageData::mutable_mime_type() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ImageData.mime_type) + return _internal_mutable_mime_type(); +} +inline const std::string& ImageData::_internal_mime_type() const { + return mime_type_.GetNoArena(); +} +inline void ImageData::_internal_set_mime_type(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + mime_type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void ImageData::set_mime_type(std::string&& value) { + _has_bits_[0] |= 0x00000002u; + mime_type_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.ImageData.mime_type) +} +inline void ImageData::set_mime_type(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000002u; + mime_type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.ImageData.mime_type) +} +inline void ImageData::set_mime_type(const char* value, size_t size) { + _has_bits_[0] |= 0x00000002u; + mime_type_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.ImageData.mime_type) +} +inline std::string* ImageData::_internal_mutable_mime_type() { + _has_bits_[0] |= 0x00000002u; + return mime_type_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ImageData::release_mime_type() { + // @@protoc_insertion_point(field_release:safe_browsing.ImageData.mime_type) + if (!_internal_has_mime_type()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + return mime_type_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ImageData::set_allocated_mime_type(std::string* mime_type) { + if (mime_type != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + mime_type_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mime_type); + // @@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 = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || dimensions_ != nullptr); + return value; +} +inline bool ImageData::has_dimensions() const { + return _internal_has_dimensions(); +} +inline void ImageData::clear_dimensions() { + if (dimensions_ != nullptr) dimensions_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::safe_browsing::ImageData_Dimensions& ImageData::_internal_dimensions() const { + const ::safe_browsing::ImageData_Dimensions* p = 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 ::safe_browsing::ImageData_Dimensions* ImageData::release_dimensions() { + // @@protoc_insertion_point(field_release:safe_browsing.ImageData.dimensions) + _has_bits_[0] &= ~0x00000004u; + ::safe_browsing::ImageData_Dimensions* temp = dimensions_; + dimensions_ = nullptr; + return temp; +} +inline ::safe_browsing::ImageData_Dimensions* ImageData::_internal_mutable_dimensions() { + _has_bits_[0] |= 0x00000004u; + if (dimensions_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ImageData_Dimensions>(GetArenaNoVirtual()); + dimensions_ = p; + } + return dimensions_; +} +inline ::safe_browsing::ImageData_Dimensions* ImageData::mutable_dimensions() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ImageData.dimensions) + return _internal_mutable_dimensions(); +} +inline void ImageData::set_allocated_dimensions(::safe_browsing::ImageData_Dimensions* dimensions) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete dimensions_; + } + if (dimensions) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + dimensions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, dimensions, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + 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 = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || original_dimensions_ != nullptr); + return value; +} +inline bool ImageData::has_original_dimensions() const { + return _internal_has_original_dimensions(); +} +inline void ImageData::clear_original_dimensions() { + if (original_dimensions_ != nullptr) original_dimensions_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::safe_browsing::ImageData_Dimensions& ImageData::_internal_original_dimensions() const { + const ::safe_browsing::ImageData_Dimensions* p = 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 ::safe_browsing::ImageData_Dimensions* ImageData::release_original_dimensions() { + // @@protoc_insertion_point(field_release:safe_browsing.ImageData.original_dimensions) + _has_bits_[0] &= ~0x00000008u; + ::safe_browsing::ImageData_Dimensions* temp = original_dimensions_; + original_dimensions_ = nullptr; + return temp; +} +inline ::safe_browsing::ImageData_Dimensions* ImageData::_internal_mutable_original_dimensions() { + _has_bits_[0] |= 0x00000008u; + if (original_dimensions_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ImageData_Dimensions>(GetArenaNoVirtual()); + original_dimensions_ = p; + } + return original_dimensions_; +} +inline ::safe_browsing::ImageData_Dimensions* ImageData::mutable_original_dimensions() { + // @@protoc_insertion_point(field_mutable:safe_browsing.ImageData.original_dimensions) + return _internal_mutable_original_dimensions(); +} +inline void ImageData::set_allocated_original_dimensions(::safe_browsing::ImageData_Dimensions* original_dimensions) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete original_dimensions_; + } + if (original_dimensions) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + original_dimensions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, original_dimensions, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + 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 = (_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() { + notification_origin_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _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(); +} +inline void NotificationImageReportRequest::set_notification_origin(const std::string& value) { + _internal_set_notification_origin(value); + // @@protoc_insertion_point(field_set:safe_browsing.NotificationImageReportRequest.notification_origin) +} +inline std::string* NotificationImageReportRequest::mutable_notification_origin() { + // @@protoc_insertion_point(field_mutable:safe_browsing.NotificationImageReportRequest.notification_origin) + return _internal_mutable_notification_origin(); +} +inline const std::string& NotificationImageReportRequest::_internal_notification_origin() const { + return notification_origin_.GetNoArena(); +} +inline void NotificationImageReportRequest::_internal_set_notification_origin(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + notification_origin_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); +} +inline void NotificationImageReportRequest::set_notification_origin(std::string&& value) { + _has_bits_[0] |= 0x00000001u; + notification_origin_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:safe_browsing.NotificationImageReportRequest.notification_origin) +} +inline void NotificationImageReportRequest::set_notification_origin(const char* value) { + GOOGLE_DCHECK(value != nullptr); + _has_bits_[0] |= 0x00000001u; + notification_origin_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:safe_browsing.NotificationImageReportRequest.notification_origin) +} +inline void NotificationImageReportRequest::set_notification_origin(const char* value, size_t size) { + _has_bits_[0] |= 0x00000001u; + notification_origin_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast<const char*>(value), size)); + // @@protoc_insertion_point(field_set_pointer:safe_browsing.NotificationImageReportRequest.notification_origin) +} +inline std::string* NotificationImageReportRequest::_internal_mutable_notification_origin() { + _has_bits_[0] |= 0x00000001u; + return notification_origin_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* NotificationImageReportRequest::release_notification_origin() { + // @@protoc_insertion_point(field_release:safe_browsing.NotificationImageReportRequest.notification_origin) + if (!_internal_has_notification_origin()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + return notification_origin_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void NotificationImageReportRequest::set_allocated_notification_origin(std::string* notification_origin) { + if (notification_origin != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + notification_origin_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), notification_origin); + // @@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 = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || image_ != nullptr); + return value; +} +inline bool NotificationImageReportRequest::has_image() const { + return _internal_has_image(); +} +inline void NotificationImageReportRequest::clear_image() { + if (image_ != nullptr) image_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::safe_browsing::ImageData& NotificationImageReportRequest::_internal_image() const { + const ::safe_browsing::ImageData* p = 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 ::safe_browsing::ImageData* NotificationImageReportRequest::release_image() { + // @@protoc_insertion_point(field_release:safe_browsing.NotificationImageReportRequest.image) + _has_bits_[0] &= ~0x00000002u; + ::safe_browsing::ImageData* temp = image_; + image_ = nullptr; + return temp; +} +inline ::safe_browsing::ImageData* NotificationImageReportRequest::_internal_mutable_image() { + _has_bits_[0] |= 0x00000002u; + if (image_ == nullptr) { + auto* p = CreateMaybeMessage<::safe_browsing::ImageData>(GetArenaNoVirtual()); + image_ = p; + } + return image_; +} +inline ::safe_browsing::ImageData* NotificationImageReportRequest::mutable_image() { + // @@protoc_insertion_point(field_mutable:safe_browsing.NotificationImageReportRequest.image) + return _internal_mutable_image(); +} +inline void NotificationImageReportRequest::set_allocated_image(::safe_browsing::ImageData* image) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete image_; + } + if (image) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + image = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, image, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + 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..db1e49b49a --- /dev/null +++ b/toolkit/components/reputationservice/moz.build @@ -0,0 +1,47 @@ +# -*- 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 + +if CONFIG["CC_TYPE"] in ("clang", "gcc"): + CXXFLAGS += ["-Wno-shadow"] + +include("/ipc/chromium/chromium-config.mozbuild") + + +if CONFIG["ENABLE_TESTS"]: + DIRS += ["test/gtest"] diff --git a/toolkit/components/reputationservice/nsIApplicationReputation.idl b/toolkit/components/reputationservice/nsIApplicationReputation.idl new file mode 100644 index 0000000000..cd5f503d30 --- /dev/null +++ b/toolkit/components/reputationservice/nsIApplicationReputation.idl @@ -0,0 +1,136 @@ +/* -*- 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); +}; + +/** + * 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..5b674e34cb --- /dev/null +++ b/toolkit/components/reputationservice/test/gtest/TestExecutableLists.cpp @@ -0,0 +1,372 @@ +/* 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 + ".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 + ".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 + ".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 + ".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..5ba7445f4a --- /dev/null +++ b/toolkit/components/reputationservice/test/gtest/moz.build @@ -0,0 +1,16 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +LOCAL_INCLUDES += [ + "../..", +] + +DEFINES["GOOGLE_PROTOBUF_NO_RTTI"] = True +DEFINES["GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER"] = True + +UNIFIED_SOURCES += ["TestExecutableLists.cpp"] + +FINAL_LIBRARY = "xul-gtest" diff --git a/toolkit/components/reputationservice/test/unit/data/block_digest.chunk b/toolkit/components/reputationservice/test/unit/data/block_digest.chunk new file mode 100644 index 0000000000..34c47c4bb5 --- /dev/null +++ b/toolkit/components/reputationservice/test/unit/data/block_digest.chunk @@ -0,0 +1,2 @@ +a:5:32:37 +,AÎJ,AÎJ„ä8æW´bbòñ_e‹ ;OÏÏ„CVù
\ No newline at end of file diff --git a/toolkit/components/reputationservice/test/unit/data/digest.chunk b/toolkit/components/reputationservice/test/unit/data/digest.chunk new file mode 100644 index 0000000000..b1fbb46673 --- /dev/null +++ b/toolkit/components/reputationservice/test/unit/data/digest.chunk @@ -0,0 +1,3 @@ +a:5:32:64 +“Ê_Há^˜aÍ7ÂÙ]´=#ÌnmåÃøún‹æo—ÌQ‰÷ãÍ +‡É@.R0ðD©7Y4±íËퟆËS$³8
\ No newline at end of file diff --git a/toolkit/components/reputationservice/test/unit/data/signed_win.exe b/toolkit/components/reputationservice/test/unit/data/signed_win.exe 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..a1d1ad3647 --- /dev/null +++ b/toolkit/components/reputationservice/test/unit/head_download_manager.js @@ -0,0 +1,135 @@ +/* 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.import( + "resource://gre/modules/XPCOMUtils.jsm" +); +var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm"); +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..e32993c6b7 --- /dev/null +++ b/toolkit/components/reputationservice/test/unit/test_app_rep_windows.js @@ -0,0 +1,495 @@ +/* -*- 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, + "FileUtils", + "resource://gre/modules/FileUtils.jsm" +); +ChromeUtils.defineModuleGetter( + this, + "NetUtil", + "resource://gre/modules/NetUtil.jsm" +); +ChromeUtils.defineModuleGetter( + this, + "FileTestUtils", + "resource://testing-common/FileTestUtils.jsm" +); + +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..fcbacbe731 --- /dev/null +++ b/toolkit/components/reputationservice/test/unit/xpcshell.ini @@ -0,0 +1,14 @@ +[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] +[test_app_rep_windows.js] +skip-if = os != "win" +[test_app_rep_maclinux.js] +skip-if = os == "win" +[test_login_rep.js] |