Add m-esr52 at 52.6.0

32 files changed, 51955 insertions, 0 deletions

diff --git a/toolkit/components/downloads/ApplicationReputation.cpp b/toolkit/components/downloads/ApplicationReputation.cpp
new file mode 100644
index 000000000..7bd219dbf
--- /dev/null
+++ b/toolkit/components/downloads/ApplicationReputation.cpp
@@ -0,0 +1,1629 @@
+/* -*- 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 "nsICryptoHash.h"
+#include "nsIHttpChannel.h"
+#include "nsIIOService.h"
+#include "nsIPrefService.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 "nsIX509Cert.h"
+#include "nsIX509CertDB.h"
+#include "nsIX509CertList.h"
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/ErrorNames.h"
+#include "mozilla/LoadContext.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Services.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/TimeStamp.h"
+
+#include "nsAutoPtr.h"
+#include "nsCOMPtr.h"
+#include "nsDebug.h"
+#include "nsError.h"
+#include "nsNetCID.h"
+#include "nsReadableUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "nsThreadUtils.h"
+#include "nsXPCOMStrings.h"
+
+#include "nsIContentPolicy.h"
+#include "nsILoadInfo.h"
+#include "nsContentUtils.h"
+
+using mozilla::ArrayLength;
+using mozilla::BasePrincipal;
+using mozilla::DocShellOriginAttributes;
+using mozilla::PrincipalOriginAttributes;
+using mozilla::Preferences;
+using mozilla::TimeStamp;
+using mozilla::Telemetry::Accumulate;
+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_GENERAL_LOCALE "general.useragent.locale"
+#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)
+
+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:
+  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,
+  };
+
+  // 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, the referrer and possibly any redirects.
+  nsTArray<nsCString> mAnylistSpecs;
+
+  // 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;
+
+  // Returns true if the file is likely to be binary.
+  bool IsBinaryFile();
+
+  // Returns the type of download binary for the file.
+  ClientDownloadRequest::DownloadType GetDownloadType(const nsAString& aFilename);
+
+  // Clean up and call the callback. PendingLookup must not be used after this
+  // function is called.
+  nsresult OnComplete(bool shouldBlock, nsresult rv,
+    uint32_t verdict = nsIApplicationReputationService::VERDICT_SAFE);
+
+  // Wrapper function for nsIStreamListener.onStopRequest to make it easy to
+  // guarantee calling the callback
+  nsresult OnStopRequestInternal(nsIRequest *aRequest,
+                                 nsISupports *aContext,
+                                 nsresult aResult,
+                                 bool* aShouldBlock,
+                                 uint32_t* aVerdict);
+
+  // 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(nsIArray* aSigArray);
+
+  // Adds the redirects to mAnylistSpecs 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();
+};
+
+// 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, bool aAllowlistOnly);
+
+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;
+  bool mAllowlistOnly;
+  RefPtr<PendingLookup> mPendingLookup;
+  nsresult LookupSpecInternal(const nsACString& aSpec);
+};
+
+NS_IMPL_ISUPPORTS(PendingDBLookup,
+                  nsIUrlClassifierCallback)
+
+PendingDBLookup::PendingDBLookup(PendingLookup* aPendingLookup) :
+  mAllowlistOnly(false),
+  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,
+                            bool aAllowlistOnly)
+{
+  LOG(("Checking principal %s [this=%p]", aSpec.Data(), this));
+  mSpec = aSpec;
+  mAllowlistOnly = aAllowlistOnly;
+  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);
+
+  PrincipalOriginAttributes attrs;
+  nsCOMPtr<nsIPrincipal> principal =
+    BasePrincipal::CreateCodebasePrincipal(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 =
+    do_GetService(NS_URLCLASSIFIERDBSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString tables;
+  nsAutoCString allowlist;
+  Preferences::GetCString(PREF_DOWNLOAD_ALLOW_TABLE, &allowlist);
+  if (!allowlist.IsEmpty()) {
+    tables.Append(allowlist);
+  }
+  nsAutoCString blocklist;
+  Preferences::GetCString(PREF_DOWNLOAD_BLOCK_TABLE, &blocklist);
+  if (!mAllowlistOnly && !blocklist.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 (!mAllowlistOnly && 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(true, NS_OK,
+      nsIApplicationReputationService::VERDICT_DANGEROUS);
+  }
+
+  nsAutoCString allowList;
+  Preferences::GetCString(PREF_DOWNLOAD_ALLOW_TABLE, &allowList);
+  if (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
+  } else {
+    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)
+
+PendingLookup::PendingLookup(nsIApplicationReputationQuery* aQuery,
+                             nsIApplicationReputationCallback* aCallback) :
+  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 char16_t* kBinaryFileExtensions[] = {
+    // Extracted from the "File Type Policies" Chrome extension
+    //u".001",
+    //u".7z",
+    //u".ace",
+    //u".action", // Mac script
+    //u".ad", // Windows
+    u".ade", // MS Access
+    u".adp", // MS Access
+    u".apk", // Android package
+    u".app", // Executable application
+    u".application", // MS ClickOnce
+    u".appref-ms", // MS ClickOnce
+    //u".arc",
+    //u".arj",
+    u".as", // Mac archive
+    u".asp", // Windows Server script
+    u".asx", // Windows Media Player
+    //u".b64",
+    //u".balz",
+    u".bas", // Basic script
+    u".bash", // Linux shell
+    u".bat", // Windows shell
+    //u".bhx",
+    //u".bin",
+    u".bz", // Linux archive (bzip)
+    u".bz2", // Linux archive (bzip2)
+    u".bzip2", // Linux archive (bzip2)
+    u".cab", // Windows archive
+    u".cdr", // Mac disk image
+    u".cfg", // Windows
+    u".chi", // Windows Help
+    u".chm", // Windows Help
+    u".class", // Java
+    u".cmd", // Windows executable
+    u".com", // Windows executable
+    u".command", // Mac script
+    u".cpgz", // Mac archive
+    //u".cpio",
+    u".cpl", // Windows executable
+    u".crt", // Windows signed certificate
+    u".crx", // Chrome extensions
+    u".csh", // Linux shell
+    u".dart", // Mac disk image
+    u".dc42", // Apple DiskCopy Image
+    u".deb", // Linux package
+    u".dex", // Android
+    u".diskcopy42", // Apple DiskCopy Image
+    u".dll", // Windows executable
+    u".dmg", // Mac disk image
+    u".dmgpart", // Mac disk image
+    //u".docb", // MS Office
+    //u".docm", // MS Word
+    //u".docx", // MS Word
+    //u".dotm", // MS Word
+    //u".dott", // MS Office
+    u".drv", // Windows driver
+    u".dvdr", // Mac Disk image
+    u".efi", // Firmware
+    u".eml", // MS Outlook
+    u".exe", // Windows executable
+    //u".fat",
+    u".fon", // Windows font
+    u".fxp", // MS FoxPro
+    u".gadget", // Windows
+    u".grp", // Windows
+    u".gz", // Linux archive (gzip)
+    u".gzip", // Linux archive (gzip)
+    u".hfs", // Mac disk image
+    u".hlp", // Windows Help
+    u".hqx", // Mac archive
+    u".hta", // HTML trusted application
+    u".htt", // MS HTML template
+    u".img", // Mac disk image
+    u".imgpart", // Mac disk image
+    u".inf", // Windows installer
+    u".ini", // Generic config file
+    u".ins", // IIS config
+    //u".inx", // InstallShield
+    u".iso", // CD image
+    u".isp", // IIS config
+    //u".isu", // InstallShield
+    u".jar", // Java
+    u".jnlp", // Java
+    //u".job", // Windows
+    u".js", // JavaScript script
+    u".jse", // JScript
+    u".ksh", // Linux shell
+    //u".lha",
+    u".lnk", // Windows
+    u".local", // Windows
+    //u".lpaq1",
+    //u".lpaq5",
+    //u".lpaq8",
+    //u".lzh",
+    //u".lzma",
+    u".mad", // MS Access
+    u".maf", // MS Access
+    u".mag", // MS Access
+    u".mam", // MS Access
+    u".manifest", // Windows
+    u".maq", // MS Access
+    u".mar", // MS Access
+    u".mas", // MS Access
+    u".mat", // MS Access
+    u".mau", // Media attachment
+    u".mav", // MS Access
+    u".maw", // MS Access
+    u".mda", // MS Access
+    u".mdb", // MS Access
+    u".mde", // MS Access
+    u".mdt", // MS Access
+    u".mdw", // MS Access
+    u".mdz", // MS Access
+    u".mht", // MS HTML
+    u".mhtml", // MS HTML
+    u".mim", // MS Mail
+    u".mmc", // MS Office
+    u".mof", // Windows
+    u".mpkg", // Mac installer
+    u".msc", // Windows executable
+    u".msg", // MS Outlook
+    u".msh", // Windows shell
+    u".msh1", // Windows shell
+    u".msh1xml", // Windows shell
+    u".msh2", // Windows shell
+    u".msh2xml", // Windows shell
+    u".mshxml", // Windows
+    u".msi", // Windows installer
+    u".msp", // Windows installer
+    u".mst", // Windows installer
+    u".ndif", // Mac disk image
+    //u".ntfs", // 7z
+    u".ocx", // ActiveX
+    u".ops", // MS Office
+    //u".out", // Linux binary
+    //u".paf", // PortableApps package
+    //u".paq8f",
+    //u".paq8jd",
+    //u".paq8l",
+    //u".paq8o",
+    u".partial", // Downloads
+    u".pax", // Mac archive
+    u".pcd", // Microsoft Visual Test
+    u".pdf", // Adobe Acrobat
+    //u".pea",
+    u".pet", // Linux package
+    u".pif", // Windows
+    u".pkg", // Mac installer
+    u".pl", // Perl script
+    u".plg", // MS Visual Studio
+    //u".potx", // MS PowerPoint
+    //u".ppam", // MS PowerPoint
+    //u".ppsx", // MS PowerPoint
+    //u".pptm", // MS PowerPoint
+    //u".pptx", // MS PowerPoint
+    u".prf", // MS Outlook
+    u".prg", // Windows
+    u".ps1", // Windows shell
+    u".ps1xml", // Windows shell
+    u".ps2", // Windows shell
+    u".ps2xml", // Windows shell
+    u".psc1", // Windows shell
+    u".psc2", // Windows shell
+    u".pst", // MS Outlook
+    u".pup", // Linux package
+    u".py", // Python script
+    u".pyc", // Python binary
+    u".pyw", // Python GUI
+    //u".quad",
+    //u".r00",
+    //u".r01",
+    //u".r02",
+    //u".r03",
+    //u".r04",
+    //u".r05",
+    //u".r06",
+    //u".r07",
+    //u".r08",
+    //u".r09",
+    //u".r10",
+    //u".r11",
+    //u".r12",
+    //u".r13",
+    //u".r14",
+    //u".r15",
+    //u".r16",
+    //u".r17",
+    //u".r18",
+    //u".r19",
+    //u".r20",
+    //u".r21",
+    //u".r22",
+    //u".r23",
+    //u".r24",
+    //u".r25",
+    //u".r26",
+    //u".r27",
+    //u".r28",
+    //u".r29",
+    //u".rar",
+    u".rb", // Ruby script
+    u".reg", // Windows Registry
+    u".rels", // MS Office
+    //u".rgs", // Windows Registry
+    u".rpm", // Linux package
+    //u".rtf", // MS Office
+    //u".run", // Linux shell
+    u".scf", // Windows shell
+    u".scr", // Windows
+    u".sct", // Windows shell
+    u".search-ms", // Windows
+    u".sh", // Linux shell
+    u".shar", // Linux shell
+    u".shb", // Windows
+    u".shs", // Windows shell
+    //u".sldm", // MS PowerPoint
+    //u".sldx", // MS PowerPoint
+    u".slp", // Linux package
+    u".smi", // Mac disk image
+    u".sparsebundle", // Mac disk image
+    u".sparseimage", // Mac disk image
+    u".spl", // Adobe Flash
+    //u".squashfs",
+    u".svg",
+    u".swf", // Adobe Flash
+    u".swm", // Windows Imaging
+    u".sys", // Windows
+    u".tar", // Linux archive
+    u".taz", // Linux archive (bzip2)
+    u".tbz", // Linux archive (bzip2)
+    u".tbz2", // Linux archive (bzip2)
+    u".tcsh", // Linux shell
+    u".tgz", // Linux archive (gzip)
+    //u".toast", // Roxio disk image
+    //u".torrent", // Bittorrent
+    u".tpz", // Linux archive (gzip)
+    u".txz", // Linux archive (xz)
+    u".tz", // Linux archive (gzip)
+    //u".u3p", // U3 Smart Apps
+    u".udf", // MS Excel
+    u".udif", // Mac disk image
+    u".url", // Windows
+    //u".uu",
+    //u".uue",
+    u".vb", // Visual Basic script
+    u".vbe", // Visual Basic script
+    u".vbs", // Visual Basic script
+    //u".vbscript", // Visual Basic script
+    u".vhd", // Windows virtual hard drive
+    u".vhdx", // Windows virtual hard drive
+    u".vmdk", // VMware virtual disk
+    u".vsd", // MS Visio
+    u".vsmacros", // MS Visual Studio
+    u".vss", // MS Visio
+    u".vst", // MS Visio
+    u".vsw", // MS Visio
+    u".website",  // Windows
+    u".wim", // Windows Imaging
+    //u".workflow", // Mac Automator
+    //u".wrc", // FreeArc archive
+    u".ws", // Windows script
+    u".wsc", // Windows script
+    u".wsf", // Windows script
+    u".wsh", // Windows script
+    u".xar", // MS Excel
+    u".xbap", // XAML Browser Application
+    u".xip", // Mac archive
+    //u".xlsm", // MS Excel
+    //u".xlsx", // MS Excel
+    //u".xltm", // MS Excel
+    //u".xltx", // MS Excel
+    u".xml",
+    u".xnk", // MS Exchange
+    u".xrm-ms", // Windows
+    u".xsl", // XML Stylesheet
+    //u".xxe",
+    u".xz", // Linux archive (xz)
+    u".z", // InstallShield
+#ifdef XP_WIN // disable on Mac/Linux, see 1167493
+    u".zip", // Generic archive
+#endif
+    u".zipx", // WinZip
+    //u".zpaq",
+};
+
+bool
+PendingLookup::IsBinaryFile()
+{
+  nsString fileName;
+  nsresult rv = mQuery->GetSuggestedFileName(fileName);
+  if (NS_FAILED(rv)) {
+    LOG(("No suggested filename [this = %p]", this));
+    return false;
+  }
+  LOG(("Suggested filename: %s [this = %p]",
+       NS_ConvertUTF16toUTF8(fileName).get(), this));
+
+  for (size_t i = 0; i < ArrayLength(kBinaryFileExtensions); ++i) {
+    if (StringEndsWith(fileName, nsDependentString(kBinaryFileExtensions[i]))) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+ClientDownloadRequest::DownloadType
+PendingLookup::GetDownloadType(const nsAString& aFilename) {
+  MOZ_ASSERT(IsBinaryFile());
+
+  // From https://cs.chromium.org/chromium/src/chrome/common/safe_browsing/download_protection_util.cc?l=17
+  if (StringEndsWith(aFilename, NS_LITERAL_STRING(".zip"))) {
+    return ClientDownloadRequest::ZIPPED_EXECUTABLE;
+  } else if (StringEndsWith(aFilename, NS_LITERAL_STRING(".apk"))) {
+    return ClientDownloadRequest::ANDROID_APK;
+  } else if (StringEndsWith(aFilename, NS_LITERAL_STRING(".app")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".cdr")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".dart")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".dc42")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".diskcopy42")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".dmg")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".dmgpart")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".dvdr")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".img")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".imgpart")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".iso")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".mpkg")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".ndif")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".pkg")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".smi")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".sparsebundle")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".sparseimage")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".toast")) ||
+             StringEndsWith(aFilename, NS_LITERAL_STRING(".udif"))) {
+    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 (mBlocklistCount > 0) {
+    return OnComplete(true, NS_OK,
+                      nsIApplicationReputationService::VERDICT_DANGEROUS);
+  }
+  int index = mAnylistSpecs.Length() - 1;
+  nsCString spec;
+  if (index >= 0) {
+    // Check the source URI, referrer and redirect chain.
+    spec = mAnylistSpecs[index];
+    mAnylistSpecs.RemoveElementAt(index);
+    RefPtr<PendingDBLookup> lookup(new PendingDBLookup(this));
+    return lookup->LookupSpec(spec, false);
+  }
+  // If any of mAnylistSpecs matched the blocklist, go ahead and block.
+  if (mBlocklistCount > 0) {
+    return OnComplete(true, NS_OK,
+                      nsIApplicationReputationService::VERDICT_DANGEROUS);
+  }
+  // If any of mAnylistSpecs matched the allowlist, go ahead and pass.
+  if (mAllowlistCount > 0) {
+    return OnComplete(false, NS_OK);
+  }
+  // Only binary signatures remain.
+  index = mAllowlistSpecs.Length() - 1;
+  if (index >= 0) {
+    spec = mAllowlistSpecs[index];
+    LOG(("PendingLookup::LookupNext: checking %s on allowlist", spec.get()));
+    mAllowlistSpecs.RemoveElementAt(index);
+    RefPtr<PendingDBLookup> lookup(new PendingDBLookup(this));
+    return lookup->LookupSpec(spec, true);
+  }
+  // There are no more URIs to check against local list. If the file is
+  // not eligible for remote lookup, bail.
+  if (!IsBinaryFile()) {
+    LOG(("Not eligible for remote lookups [this=%x]", this));
+    return OnComplete(false, NS_OK);
+  }
+  nsresult rv = SendRemoteQuery();
+  if (NS_FAILED(rv)) {
+    return OnComplete(false, 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;
+  rv = certDB->ConstructX509(
+    const_cast<char *>(aChain.element(0).certificate().data()),
+    aChain.element(0).certificate().size(), getter_AddRefs(signer));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (int i = 1; i < aChain.element_size(); ++i) {
+    // Get the issuer.
+    nsCOMPtr<nsIX509Cert> issuer;
+    rv = certDB->ConstructX509(
+      const_cast<char *>(aChain.element(i).certificate().data()),
+      aChain.element(i).certificate().size(), 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<nsIPrincipal> principal = do_QueryInterface(supports, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIURI> uri;
+    rv = principal->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);
+    mAnylistSpecs.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(false, 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<const 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.Append("://");
+  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<nsIURI> referrer = nullptr;
+  rv = mQuery->GetReferrerURI(getter_AddRefs(referrer));
+  if (referrer) {
+    nsCString referrerSpec;
+    rv = GetStrippedSpec(referrer, referrerSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+    mAnylistSpecs.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));
+  }
+
+  // Extract the signature and parse certificates so we can use it to check
+  // whitelists.
+  nsCOMPtr<nsIArray> sigArray;
+  rv = mQuery->GetSignatureInfo(getter_AddRefs(sigArray));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (sigArray) {
+    rv = ParseCertificates(sigArray);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  rv = GenerateWhitelistStrings();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Start the call chain.
+  return LookupNext();
+}
+
+nsresult
+PendingLookup::OnComplete(bool shouldBlock, nsresult rv, uint32_t verdict)
+{
+  MOZ_ASSERT(!shouldBlock ||
+             verdict != nsIApplicationReputationService::VERDICT_SAFE);
+
+  if (NS_FAILED(rv)) {
+    nsAutoCString errorName;
+    mozilla::GetErrorName(rv, errorName);
+    LOG(("Failed sending remote query for application reputation "
+         "[rv = %s, this = %p]", errorName.get(), this));
+  }
+
+  if (mTimeoutTimer) {
+    mTimeoutTimer->Cancel();
+    mTimeoutTimer = nullptr;
+  }
+
+  Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SHOULD_BLOCK,
+    shouldBlock);
+  double t = (TimeStamp::Now() - mStartTime).ToMilliseconds();
+  LOG(("Application Reputation verdict is %lu, obtained in %f ms [this = %p]",
+       verdict, 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, rv, verdict);
+  return res;
+}
+
+nsresult
+PendingLookup::ParseCertificates(nsIArray* aSigArray)
+{
+  // If we haven't been set for any reason, bail.
+  NS_ENSURE_ARG_POINTER(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)
+  nsCOMPtr<nsISimpleEnumerator> chains;
+  nsresult rv = aSigArray->Enumerate(getter_AddRefs(chains));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool hasMoreChains = false;
+  rv = chains->HasMoreElements(&hasMoreChains);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  while (hasMoreChains) {
+    nsCOMPtr<nsISupports> chainSupports;
+    rv = chains->GetNext(getter_AddRefs(chainSupports));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIX509CertList> certList = do_QueryInterface(chainSupports, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    safe_browsing::ClientDownloadRequest_CertificateChain* certChain =
+      mRequest.mutable_signature()->add_certificate_chain();
+    nsCOMPtr<nsISimpleEnumerator> chainElt;
+    rv = certList->GetEnumerator(getter_AddRefs(chainElt));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Each chain may have multiple certificates.
+    bool hasMoreCerts = false;
+    rv = chainElt->HasMoreElements(&hasMoreCerts);
+    while (hasMoreCerts) {
+      nsCOMPtr<nsISupports> certSupports;
+      rv = chainElt->GetNext(getter_AddRefs(certSupports));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCOMPtr<nsIX509Cert> cert = do_QueryInterface(certSupports, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      uint8_t* data = nullptr;
+      uint32_t len = 0;
+      rv = cert->GetRawDER(&len, &data);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Add this certificate to the protobuf to send remotely.
+      certChain->add_element()->set_certificate(data, len);
+      free(data);
+
+      rv = chainElt->HasMoreElements(&hasMoreCerts);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    rv = chains->HasMoreElements(&hasMoreChains);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  if (mRequest.signature().certificate_chain_size() > 0) {
+    mRequest.mutable_signature()->set_trusted(true);
+  }
+  return NS_OK;
+}
+
+nsresult
+PendingLookup::SendRemoteQuery()
+{
+  nsresult rv = SendRemoteQueryInternal();
+  if (NS_FAILED(rv)) {
+    return OnComplete(false, rv);
+  }
+  // SendRemoteQueryInternal has fired off the query and we call OnComplete in
+  // the nsIStreamListener.onStopRequest.
+  return rv;
+}
+
+nsresult
+PendingLookup::SendRemoteQueryInternal()
+{
+  // 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));
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  // If the remote lookup URL is empty or absent, bail.
+  nsCString serviceUrl;
+  NS_ENSURE_SUCCESS(Preferences::GetCString(PREF_SB_APP_REP_URL, &serviceUrl),
+                    NS_ERROR_NOT_AVAILABLE);
+  if (serviceUrl.IsEmpty()) {
+    LOG(("Remote lookup URL is empty [this = %p]", this));
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  // If the blocklist or allowlist is empty (so we couldn't do local lookups),
+  // bail
+  {
+    nsAutoCString table;
+    NS_ENSURE_SUCCESS(Preferences::GetCString(PREF_DOWNLOAD_BLOCK_TABLE,
+                                              &table),
+                      NS_ERROR_NOT_AVAILABLE);
+    if (table.IsEmpty()) {
+      LOG(("Blocklist is empty [this = %p]", this));
+      return NS_ERROR_NOT_AVAILABLE;
+    }
+  }
+#ifdef XP_WIN
+  // The allowlist is only needed to do signature verification on Windows
+  {
+    nsAutoCString table;
+    NS_ENSURE_SUCCESS(Preferences::GetCString(PREF_DOWNLOAD_ALLOW_TABLE,
+                                              &table),
+                      NS_ERROR_NOT_AVAILABLE);
+    if (table.IsEmpty()) {
+      LOG(("Allowlist is empty [this = %p]", this));
+      return NS_ERROR_NOT_AVAILABLE;
+    }
+  }
+#endif
+
+  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;
+  NS_ENSURE_SUCCESS(Preferences::GetCString(PREF_GENERAL_LOCALE, &locale),
+                    NS_ERROR_NOT_AVAILABLE);
+  mRequest.set_locale(locale.get());
+  nsCString sha256Hash;
+  rv = mQuery->GetSha256Hash(sha256Hash);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mRequest.mutable_digests()->set_sha256(sha256Hash.Data());
+  nsString fileName;
+  rv = mQuery->GetSuggestedFileName(fileName);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mRequest.set_file_basename(NS_ConvertUTF16toUTF8(fileName).get());
+  mRequest.set_download_type(GetDownloadType(fileName));
+
+  if (mRequest.signature().trusted()) {
+    LOG(("Got signed binary for remote application reputation check "
+         "[this = %p]", this));
+  } else {
+    LOG(("Got unsigned binary for remote application reputation check "
+         "[this = %p]", this));
+  }
+
+  // Serialize the protocol buffer to a string. This can only fail if we are
+  // out of memory, or if the protocol buffer req is missing required fields
+  // (only the URL for now).
+  std::string serialized;
+  if (!mRequest.SerializeToString(&serialized)) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  LOG(("Serialized protocol buffer [this = %p]: (length=%d) %s", this,
+       serialized.length(), serialized.c_str()));
+
+  // 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->NewChannel2(serviceUrl,
+                        nullptr,
+                        nullptr,
+                        nullptr, // aLoadingNode
+                        nsContentUtils::GetSystemPrincipal(),
+                        nullptr, // aTriggeringPrincipal
+                        nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
+                        nsIContentPolicy::TYPE_OTHER,
+                        getter_AddRefs(mChannel));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
+  if (loadInfo) {
+    loadInfo->SetOriginAttributes(
+      mozilla::NeckoOriginAttributes(NECKO_SAFEBROWSING_APP_ID, false));
+  }
+
+  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,
+    NS_LITERAL_CSTRING("application/octet-stream"), serialized.size(),
+    NS_LITERAL_CSTRING("POST"), false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Set the Safebrowsing cookie jar, so that the regular Google cookie is not
+  // sent with this request. See bug 897516.
+  DocShellOriginAttributes attrs;
+  attrs.mAppId = NECKO_SAFEBROWSING_APP_ID;
+  nsCOMPtr<nsIInterfaceRequestor> loadContext = new mozilla::LoadContext(attrs);
+  rv = mChannel->SetNotificationCallbacks(loadContext);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t timeoutMs = Preferences::GetUint(PREF_SB_DOWNLOADS_REMOTE_TIMEOUT, 10000);
+  mTimeoutTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+  mTimeoutTimer->InitWithCallback(this, timeoutMs, nsITimer::TYPE_ONE_SHOT);
+
+  rv = mChannel->AsyncOpen2(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,
+                               nsISupports *aContext,
+                               nsIInputStream *aStream,
+                               uint64_t offset,
+                               uint32_t count) {
+  uint32_t read;
+  return aStream->ReadSegments(AppendSegmentToString, &mResponse, count, &read);
+}
+
+NS_IMETHODIMP
+PendingLookup::OnStartRequest(nsIRequest *aRequest,
+                              nsISupports *aContext) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PendingLookup::OnStopRequest(nsIRequest *aRequest,
+                             nsISupports *aContext,
+                             nsresult aResult) {
+  NS_ENSURE_STATE(mCallback);
+
+  bool shouldBlock = false;
+  uint32_t verdict = nsIApplicationReputationService::VERDICT_SAFE;
+  Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_REMOTE_LOOKUP_TIMEOUT,
+    false);
+
+  nsresult rv = OnStopRequestInternal(aRequest, aContext, aResult,
+                                      &shouldBlock, &verdict);
+  OnComplete(shouldBlock, rv, verdict);
+  return rv;
+}
+
+nsresult
+PendingLookup::OnStopRequestInternal(nsIRequest *aRequest,
+                                     nsISupports *aContext,
+                                     nsresult aResult,
+                                     bool* aShouldBlock,
+                                     uint32_t* aVerdict) {
+  if (NS_FAILED(aResult)) {
+    Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SERVER,
+      SERVER_RESPONSE_FAILED);
+    return aResult;
+  }
+
+  *aShouldBlock = false;
+  *aVerdict = nsIApplicationReputationService::VERDICT_SAFE;
+  nsresult rv;
+  nsCOMPtr<nsIHttpChannel> channel = do_QueryInterface(aRequest, &rv);
+  if (NS_FAILED(rv)) {
+    Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SERVER,
+      SERVER_RESPONSE_FAILED);
+    return rv;
+  }
+
+  uint32_t status = 0;
+  rv = channel->GetResponseStatus(&status);
+  if (NS_FAILED(rv)) {
+    Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SERVER,
+      SERVER_RESPONSE_FAILED);
+    return rv;
+  }
+
+  if (status != 200) {
+    Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_SERVER,
+      SERVER_RESPONSE_FAILED);
+    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);
+  // 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));
+  switch(response.verdict()) {
+    case safe_browsing::ClientDownloadResponse::DANGEROUS:
+      *aShouldBlock = Preferences::GetBool(PREF_BLOCK_DANGEROUS, true);
+      *aVerdict = nsIApplicationReputationService::VERDICT_DANGEROUS;
+      break;
+    case safe_browsing::ClientDownloadResponse::DANGEROUS_HOST:
+      *aShouldBlock = Preferences::GetBool(PREF_BLOCK_DANGEROUS_HOST, true);
+      *aVerdict = nsIApplicationReputationService::VERDICT_DANGEROUS_HOST;
+      break;
+    case safe_browsing::ClientDownloadResponse::POTENTIALLY_UNWANTED:
+      *aShouldBlock = Preferences::GetBool(PREF_BLOCK_POTENTIALLY_UNWANTED, false);
+      *aVerdict = nsIApplicationReputationService::VERDICT_POTENTIALLY_UNWANTED;
+      break;
+    case safe_browsing::ClientDownloadResponse::UNCOMMON:
+      *aShouldBlock = Preferences::GetBool(PREF_BLOCK_UNCOMMON, false);
+      *aVerdict = nsIApplicationReputationService::VERDICT_UNCOMMON;
+      break;
+    default:
+      // Treat everything else as safe
+      break;
+  }
+
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(ApplicationReputationService,
+                  nsIApplicationReputationService)
+
+ApplicationReputationService*
+  ApplicationReputationService::gApplicationReputationService = nullptr;
+
+ApplicationReputationService*
+ApplicationReputationService::GetSingleton()
+{
+  if (gApplicationReputationService) {
+    NS_ADDREF(gApplicationReputationService);
+    return gApplicationReputationService;
+  }
+
+  // We're not initialized yet.
+  gApplicationReputationService = new ApplicationReputationService();
+  if (gApplicationReputationService) {
+    NS_ADDREF(gApplicationReputationService);
+  }
+
+  return 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);
+
+  Accumulate(mozilla::Telemetry::APPLICATION_REPUTATION_COUNT, true);
+  nsresult rv = QueryReputationInternal(aQuery, aCallback);
+  if (NS_FAILED(rv)) {
+    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) {
+  nsresult rv;
+  // 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;
+  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", false);
+  return lookup->StartLookup();
+}
diff --git a/toolkit/components/downloads/ApplicationReputation.h b/toolkit/components/downloads/ApplicationReputation.h
new file mode 100644
index 000000000..0ed68d616
--- /dev/null
+++ b/toolkit/components/downloads/ApplicationReputation.h
@@ -0,0 +1,55 @@
+/* -*- 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 "nsIRequestObserver.h"
+#include "nsIStreamListener.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 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/downloads/SQLFunctions.cpp b/toolkit/components/downloads/SQLFunctions.cpp
new file mode 100644
index 000000000..8f2d3e77b
--- /dev/null
+++ b/toolkit/components/downloads/SQLFunctions.cpp
@@ -0,0 +1,146 @@
+/* vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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 "mozilla/storage.h"
+#include "mozilla/storage/Variant.h"
+#include "mozilla/mozalloc.h"
+#include "nsString.h"
+#include "SQLFunctions.h"
+#include "nsUTF8Utils.h"
+#include "plbase64.h"
+#include "prio.h"
+
+#ifdef XP_WIN
+#include <windows.h>
+#include <wincrypt.h>
+#endif
+
+// The length of guids that are used by the download manager
+#define GUID_LENGTH 12
+
+namespace mozilla {
+namespace downloads {
+
+// Keep this file in sync with the GUID-related code in toolkit/places/SQLFunctions.cpp
+// and toolkit/places/Helpers.cpp!
+
+////////////////////////////////////////////////////////////////////////////////
+//// GUID Creation Function
+
+//////////////////////////////////////////////////////////////////////////////
+//// GenerateGUIDFunction
+
+/* static */
+nsresult
+GenerateGUIDFunction::create(mozIStorageConnection *aDBConn)
+{
+  RefPtr<GenerateGUIDFunction> function = new GenerateGUIDFunction();
+  nsresult rv = aDBConn->CreateFunction(
+    NS_LITERAL_CSTRING("generate_guid"), 0, function
+  );
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(
+    GenerateGUIDFunction,
+    mozIStorageFunction
+)
+
+static
+nsresult
+Base64urlEncode(const uint8_t* aBytes,
+                uint32_t aNumBytes,
+                nsCString& _result)
+{
+  // SetLength does not set aside space for null termination.  PL_Base64Encode
+  // will not null terminate, however, nsCStrings must be null terminated.  As a
+  // result, we set the capacity to be one greater than what we need, and the
+  // length to our desired length.
+  uint32_t length = (aNumBytes + 2) / 3 * 4; // +2 due to integer math.
+  NS_ENSURE_TRUE(_result.SetCapacity(length + 1, mozilla::fallible),
+                 NS_ERROR_OUT_OF_MEMORY);
+  _result.SetLength(length);
+  (void)PL_Base64Encode(reinterpret_cast<const char*>(aBytes), aNumBytes,
+                        _result.BeginWriting());
+
+  // base64url encoding is defined in RFC 4648.  It replaces the last two
+  // alphabet characters of base64 encoding with '-' and '_' respectively.
+  _result.ReplaceChar('+', '-');
+  _result.ReplaceChar('/', '_');
+  return NS_OK;
+}
+
+static
+nsresult
+GenerateRandomBytes(uint32_t aSize,
+                    uint8_t* _buffer)
+{
+  // On Windows, we'll use its built-in cryptographic API.
+#if defined(XP_WIN)
+  HCRYPTPROV cryptoProvider;
+  BOOL rc = CryptAcquireContext(&cryptoProvider, 0, 0, PROV_RSA_FULL,
+                                CRYPT_VERIFYCONTEXT | CRYPT_SILENT);
+  if (rc) {
+    rc = CryptGenRandom(cryptoProvider, aSize, _buffer);
+    (void)CryptReleaseContext(cryptoProvider, 0);
+  }
+  return rc ? NS_OK : NS_ERROR_FAILURE;
+
+  // On Unix, we'll just read in from /dev/urandom.
+#elif defined(XP_UNIX)
+  NS_ENSURE_ARG_MAX(aSize, INT32_MAX);
+  PRFileDesc* urandom = PR_Open("/dev/urandom", PR_RDONLY, 0);
+  nsresult rv = NS_ERROR_FAILURE;
+  if (urandom) {
+    int32_t bytesRead = PR_Read(urandom, _buffer, aSize);
+    if (bytesRead == static_cast<int32_t>(aSize)) {
+      rv = NS_OK;
+    }
+    (void)PR_Close(urandom);
+  }
+  return rv;
+#endif
+}
+
+nsresult
+GenerateGUID(nsCString& _guid)
+{
+  _guid.Truncate();
+
+  // Request raw random bytes and base64url encode them.  For each set of three
+  // bytes, we get one character.
+  const uint32_t kRequiredBytesLength =
+    static_cast<uint32_t>(GUID_LENGTH / 4 * 3);
+
+  uint8_t buffer[kRequiredBytesLength];
+  nsresult rv = GenerateRandomBytes(kRequiredBytesLength, buffer);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = Base64urlEncode(buffer, kRequiredBytesLength, _guid);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ASSERTION(_guid.Length() == GUID_LENGTH, "GUID is not the right size!");
+  return NS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//// mozIStorageFunction
+
+NS_IMETHODIMP
+GenerateGUIDFunction::OnFunctionCall(mozIStorageValueArray *aArguments,
+                                     nsIVariant **_result)
+{
+  nsAutoCString guid;
+  nsresult rv = GenerateGUID(guid);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ADDREF(*_result = new mozilla::storage::UTF8TextVariant(guid));
+  return NS_OK;
+}
+
+} // namespace downloads
+} // namespace mozilla
diff --git a/toolkit/components/downloads/SQLFunctions.h b/toolkit/components/downloads/SQLFunctions.h
new file mode 100644
index 000000000..ae207788c
--- /dev/null
+++ b/toolkit/components/downloads/SQLFunctions.h
@@ -0,0 +1,46 @@
+/* vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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_downloads_SQLFunctions_h
+#define mozilla_downloads_SQLFunctions_h
+
+#include "mozIStorageFunction.h"
+#include "mozilla/Attributes.h"
+
+class nsCString;
+class mozIStorageConnection;
+
+namespace mozilla {
+namespace downloads {
+
+/**
+ * SQL function to generate a GUID for a place or bookmark item.  This is just
+ * a wrapper around GenerateGUID in SQLFunctions.cpp.
+ *
+ * @return a guid for the item.
+ * @see toolkit/components/places/SQLFunctions.h - keep this in sync
+ */
+class GenerateGUIDFunction final : public mozIStorageFunction
+{
+  ~GenerateGUIDFunction() {}
+public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_MOZISTORAGEFUNCTION
+
+  /**
+   * Registers the function with the specified database connection.
+   *
+   * @param aDBConn
+   *        The database connection to register with.
+   */
+   static nsresult create(mozIStorageConnection *aDBConn);
+};
+
+nsresult GenerateGUID(nsCString& _guid);
+
+} // namespace downloads
+} // namespace mozilla
+
+#endif
diff --git a/toolkit/components/downloads/chromium/LICENSE b/toolkit/components/downloads/chromium/LICENSE
new file mode 100644
index 000000000..a32e00ce6
--- /dev/null
+++ b/toolkit/components/downloads/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/downloads/chromium/chrome/common/safe_browsing/csd.pb.cc b/toolkit/components/downloads/chromium/chrome/common/safe_browsing/csd.pb.cc
new file mode 100644
index 000000000..d52b822c0
--- /dev/null
+++ b/toolkit/components/downloads/chromium/chrome/common/safe_browsing/csd.pb.cc
@@ -0,0 +1,20037 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: chromium/chrome/common/safe_browsing/csd.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "chromium/chrome/common/safe_browsing/csd.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+// @@protoc_insertion_point(includes)
+
+namespace safe_browsing {
+
+void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto() {
+  delete ChromeUserPopulation::default_instance_;
+  delete ClientPhishingRequest::default_instance_;
+  delete ClientPhishingRequest_Feature::default_instance_;
+  delete ClientPhishingResponse::default_instance_;
+  delete ClientMalwareRequest::default_instance_;
+  delete ClientMalwareRequest_UrlInfo::default_instance_;
+  delete ClientMalwareResponse::default_instance_;
+  delete ClientDownloadRequest::default_instance_;
+  delete ClientDownloadRequest_Digests::default_instance_;
+  delete ClientDownloadRequest_Resource::default_instance_;
+  delete ClientDownloadRequest_CertificateChain::default_instance_;
+  delete ClientDownloadRequest_CertificateChain_Element::default_instance_;
+  delete ClientDownloadRequest_ExtendedAttr::default_instance_;
+  delete ClientDownloadRequest_SignatureInfo::default_instance_;
+  delete ClientDownloadRequest_PEImageHeaders::default_instance_;
+  delete ClientDownloadRequest_PEImageHeaders_DebugData::default_instance_;
+  delete ClientDownloadRequest_MachOHeaders::default_instance_;
+  delete ClientDownloadRequest_MachOHeaders_LoadCommand::default_instance_;
+  delete ClientDownloadRequest_ImageHeaders::default_instance_;
+  delete ClientDownloadRequest_ArchivedBinary::default_instance_;
+  delete ClientDownloadRequest_URLChainEntry::default_instance_;
+  delete ClientDownloadResponse::default_instance_;
+  delete ClientDownloadResponse_MoreInfo::default_instance_;
+  delete ClientDownloadReport::default_instance_;
+  delete ClientDownloadReport_UserInformation::default_instance_;
+  delete ClientUploadResponse::default_instance_;
+  delete ClientIncidentReport::default_instance_;
+  delete ClientIncidentReport_IncidentData::default_instance_;
+  delete ClientIncidentReport_IncidentData_TrackedPreferenceIncident::default_instance_;
+  delete ClientIncidentReport_IncidentData_BinaryIntegrityIncident::default_instance_;
+  delete ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::default_instance_;
+  delete ClientIncidentReport_IncidentData_BlacklistLoadIncident::default_instance_;
+  delete ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::default_instance_;
+  delete ClientIncidentReport_IncidentData_ResourceRequestIncident::default_instance_;
+  delete ClientIncidentReport_IncidentData_SuspiciousModuleIncident::default_instance_;
+  delete ClientIncidentReport_DownloadDetails::default_instance_;
+  delete ClientIncidentReport_EnvironmentData::default_instance_;
+  delete ClientIncidentReport_EnvironmentData_OS::default_instance_;
+  delete ClientIncidentReport_EnvironmentData_OS_RegistryValue::default_instance_;
+  delete ClientIncidentReport_EnvironmentData_OS_RegistryKey::default_instance_;
+  delete ClientIncidentReport_EnvironmentData_Machine::default_instance_;
+  delete ClientIncidentReport_EnvironmentData_Process::default_instance_;
+  delete ClientIncidentReport_EnvironmentData_Process_Patch::default_instance_;
+  delete ClientIncidentReport_EnvironmentData_Process_NetworkProvider::default_instance_;
+  delete ClientIncidentReport_EnvironmentData_Process_Dll::default_instance_;
+  delete ClientIncidentReport_EnvironmentData_Process_ModuleState::default_instance_;
+  delete ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::default_instance_;
+  delete ClientIncidentReport_ExtensionData::default_instance_;
+  delete ClientIncidentReport_ExtensionData_ExtensionInfo::default_instance_;
+  delete ClientIncidentReport_NonBinaryDownloadDetails::default_instance_;
+  delete ClientIncidentResponse::default_instance_;
+  delete ClientIncidentResponse_EnvironmentRequest::default_instance_;
+  delete DownloadMetadata::default_instance_;
+  delete ClientSafeBrowsingReportRequest::default_instance_;
+  delete ClientSafeBrowsingReportRequest_HTTPHeader::default_instance_;
+  delete ClientSafeBrowsingReportRequest_HTTPRequest::default_instance_;
+  delete ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::default_instance_;
+  delete ClientSafeBrowsingReportRequest_HTTPResponse::default_instance_;
+  delete ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::default_instance_;
+  delete ClientSafeBrowsingReportRequest_Resource::default_instance_;
+}
+
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+void protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+#else
+void protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+#endif
+  ChromeUserPopulation::default_instance_ = new ChromeUserPopulation();
+  ClientPhishingRequest::default_instance_ = new ClientPhishingRequest();
+  ClientPhishingRequest_Feature::default_instance_ = new ClientPhishingRequest_Feature();
+  ClientPhishingResponse::default_instance_ = new ClientPhishingResponse();
+  ClientMalwareRequest::default_instance_ = new ClientMalwareRequest();
+  ClientMalwareRequest_UrlInfo::default_instance_ = new ClientMalwareRequest_UrlInfo();
+  ClientMalwareResponse::default_instance_ = new ClientMalwareResponse();
+  ClientDownloadRequest::default_instance_ = new ClientDownloadRequest();
+  ClientDownloadRequest_Digests::default_instance_ = new ClientDownloadRequest_Digests();
+  ClientDownloadRequest_Resource::default_instance_ = new ClientDownloadRequest_Resource();
+  ClientDownloadRequest_CertificateChain::default_instance_ = new ClientDownloadRequest_CertificateChain();
+  ClientDownloadRequest_CertificateChain_Element::default_instance_ = new ClientDownloadRequest_CertificateChain_Element();
+  ClientDownloadRequest_ExtendedAttr::default_instance_ = new ClientDownloadRequest_ExtendedAttr();
+  ClientDownloadRequest_SignatureInfo::default_instance_ = new ClientDownloadRequest_SignatureInfo();
+  ClientDownloadRequest_PEImageHeaders::default_instance_ = new ClientDownloadRequest_PEImageHeaders();
+  ClientDownloadRequest_PEImageHeaders_DebugData::default_instance_ = new ClientDownloadRequest_PEImageHeaders_DebugData();
+  ClientDownloadRequest_MachOHeaders::default_instance_ = new ClientDownloadRequest_MachOHeaders();
+  ClientDownloadRequest_MachOHeaders_LoadCommand::default_instance_ = new ClientDownloadRequest_MachOHeaders_LoadCommand();
+  ClientDownloadRequest_ImageHeaders::default_instance_ = new ClientDownloadRequest_ImageHeaders();
+  ClientDownloadRequest_ArchivedBinary::default_instance_ = new ClientDownloadRequest_ArchivedBinary();
+  ClientDownloadRequest_URLChainEntry::default_instance_ = new ClientDownloadRequest_URLChainEntry();
+  ClientDownloadResponse::default_instance_ = new ClientDownloadResponse();
+  ClientDownloadResponse_MoreInfo::default_instance_ = new ClientDownloadResponse_MoreInfo();
+  ClientDownloadReport::default_instance_ = new ClientDownloadReport();
+  ClientDownloadReport_UserInformation::default_instance_ = new ClientDownloadReport_UserInformation();
+  ClientUploadResponse::default_instance_ = new ClientUploadResponse();
+  ClientIncidentReport::default_instance_ = new ClientIncidentReport();
+  ClientIncidentReport_IncidentData::default_instance_ = new ClientIncidentReport_IncidentData();
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident::default_instance_ = new ClientIncidentReport_IncidentData_TrackedPreferenceIncident();
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident::default_instance_ = new ClientIncidentReport_IncidentData_BinaryIntegrityIncident();
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::default_instance_ = new ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile();
+  ClientIncidentReport_IncidentData_BlacklistLoadIncident::default_instance_ = new ClientIncidentReport_IncidentData_BlacklistLoadIncident();
+  ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::default_instance_ = new ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident();
+  ClientIncidentReport_IncidentData_ResourceRequestIncident::default_instance_ = new ClientIncidentReport_IncidentData_ResourceRequestIncident();
+  ClientIncidentReport_IncidentData_SuspiciousModuleIncident::default_instance_ = new ClientIncidentReport_IncidentData_SuspiciousModuleIncident();
+  ClientIncidentReport_DownloadDetails::default_instance_ = new ClientIncidentReport_DownloadDetails();
+  ClientIncidentReport_EnvironmentData::default_instance_ = new ClientIncidentReport_EnvironmentData();
+  ClientIncidentReport_EnvironmentData_OS::default_instance_ = new ClientIncidentReport_EnvironmentData_OS();
+  ClientIncidentReport_EnvironmentData_OS_RegistryValue::default_instance_ = new ClientIncidentReport_EnvironmentData_OS_RegistryValue();
+  ClientIncidentReport_EnvironmentData_OS_RegistryKey::default_instance_ = new ClientIncidentReport_EnvironmentData_OS_RegistryKey();
+  ClientIncidentReport_EnvironmentData_Machine::default_instance_ = new ClientIncidentReport_EnvironmentData_Machine();
+  ClientIncidentReport_EnvironmentData_Process::default_instance_ = new ClientIncidentReport_EnvironmentData_Process();
+  ClientIncidentReport_EnvironmentData_Process_Patch::default_instance_ = new ClientIncidentReport_EnvironmentData_Process_Patch();
+  ClientIncidentReport_EnvironmentData_Process_NetworkProvider::default_instance_ = new ClientIncidentReport_EnvironmentData_Process_NetworkProvider();
+  ClientIncidentReport_EnvironmentData_Process_Dll::default_instance_ = new ClientIncidentReport_EnvironmentData_Process_Dll();
+  ClientIncidentReport_EnvironmentData_Process_ModuleState::default_instance_ = new ClientIncidentReport_EnvironmentData_Process_ModuleState();
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::default_instance_ = new ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification();
+  ClientIncidentReport_ExtensionData::default_instance_ = new ClientIncidentReport_ExtensionData();
+  ClientIncidentReport_ExtensionData_ExtensionInfo::default_instance_ = new ClientIncidentReport_ExtensionData_ExtensionInfo();
+  ClientIncidentReport_NonBinaryDownloadDetails::default_instance_ = new ClientIncidentReport_NonBinaryDownloadDetails();
+  ClientIncidentResponse::default_instance_ = new ClientIncidentResponse();
+  ClientIncidentResponse_EnvironmentRequest::default_instance_ = new ClientIncidentResponse_EnvironmentRequest();
+  DownloadMetadata::default_instance_ = new DownloadMetadata();
+  ClientSafeBrowsingReportRequest::default_instance_ = new ClientSafeBrowsingReportRequest();
+  ClientSafeBrowsingReportRequest_HTTPHeader::default_instance_ = new ClientSafeBrowsingReportRequest_HTTPHeader();
+  ClientSafeBrowsingReportRequest_HTTPRequest::default_instance_ = new ClientSafeBrowsingReportRequest_HTTPRequest();
+  ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::default_instance_ = new ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine();
+  ClientSafeBrowsingReportRequest_HTTPResponse::default_instance_ = new ClientSafeBrowsingReportRequest_HTTPResponse();
+  ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::default_instance_ = new ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine();
+  ClientSafeBrowsingReportRequest_Resource::default_instance_ = new ClientSafeBrowsingReportRequest_Resource();
+  ChromeUserPopulation::default_instance_->InitAsDefaultInstance();
+  ClientPhishingRequest::default_instance_->InitAsDefaultInstance();
+  ClientPhishingRequest_Feature::default_instance_->InitAsDefaultInstance();
+  ClientPhishingResponse::default_instance_->InitAsDefaultInstance();
+  ClientMalwareRequest::default_instance_->InitAsDefaultInstance();
+  ClientMalwareRequest_UrlInfo::default_instance_->InitAsDefaultInstance();
+  ClientMalwareResponse::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest_Digests::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest_Resource::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest_CertificateChain::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest_CertificateChain_Element::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest_ExtendedAttr::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest_SignatureInfo::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest_PEImageHeaders::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest_PEImageHeaders_DebugData::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest_MachOHeaders::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest_MachOHeaders_LoadCommand::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest_ImageHeaders::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest_ArchivedBinary::default_instance_->InitAsDefaultInstance();
+  ClientDownloadRequest_URLChainEntry::default_instance_->InitAsDefaultInstance();
+  ClientDownloadResponse::default_instance_->InitAsDefaultInstance();
+  ClientDownloadResponse_MoreInfo::default_instance_->InitAsDefaultInstance();
+  ClientDownloadReport::default_instance_->InitAsDefaultInstance();
+  ClientDownloadReport_UserInformation::default_instance_->InitAsDefaultInstance();
+  ClientUploadResponse::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_IncidentData::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_IncidentData_BlacklistLoadIncident::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_IncidentData_ResourceRequestIncident::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_IncidentData_SuspiciousModuleIncident::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_DownloadDetails::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_EnvironmentData::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_EnvironmentData_OS::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_EnvironmentData_OS_RegistryValue::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_EnvironmentData_OS_RegistryKey::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_EnvironmentData_Machine::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_EnvironmentData_Process::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_EnvironmentData_Process_Patch::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_EnvironmentData_Process_NetworkProvider::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_EnvironmentData_Process_Dll::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_EnvironmentData_Process_ModuleState::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_ExtensionData::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_ExtensionData_ExtensionInfo::default_instance_->InitAsDefaultInstance();
+  ClientIncidentReport_NonBinaryDownloadDetails::default_instance_->InitAsDefaultInstance();
+  ClientIncidentResponse::default_instance_->InitAsDefaultInstance();
+  ClientIncidentResponse_EnvironmentRequest::default_instance_->InitAsDefaultInstance();
+  DownloadMetadata::default_instance_->InitAsDefaultInstance();
+  ClientSafeBrowsingReportRequest::default_instance_->InitAsDefaultInstance();
+  ClientSafeBrowsingReportRequest_HTTPHeader::default_instance_->InitAsDefaultInstance();
+  ClientSafeBrowsingReportRequest_HTTPRequest::default_instance_->InitAsDefaultInstance();
+  ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::default_instance_->InitAsDefaultInstance();
+  ClientSafeBrowsingReportRequest_HTTPResponse::default_instance_->InitAsDefaultInstance();
+  ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::default_instance_->InitAsDefaultInstance();
+  ClientSafeBrowsingReportRequest_Resource::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto);
+}
+
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_once_);
+void protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_once_,
+                 &protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl);
+}
+#else
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto {
+  StaticDescriptorInitializer_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto() {
+    protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  }
+} static_descriptor_initializer_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_;
+#endif
+
+// ===================================================================
+
+bool ChromeUserPopulation_UserPopulation_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const ChromeUserPopulation_UserPopulation ChromeUserPopulation::UNKNOWN_USER_POPULATION;
+const ChromeUserPopulation_UserPopulation ChromeUserPopulation::SAFE_BROWSING;
+const ChromeUserPopulation_UserPopulation ChromeUserPopulation::EXTENDED_REPORTING;
+const ChromeUserPopulation_UserPopulation ChromeUserPopulation::UserPopulation_MIN;
+const ChromeUserPopulation_UserPopulation ChromeUserPopulation::UserPopulation_MAX;
+const int ChromeUserPopulation::UserPopulation_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ChromeUserPopulation::kUserPopulationFieldNumber;
+#endif  // !_MSC_VER
+
+ChromeUserPopulation::ChromeUserPopulation()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ChromeUserPopulation)
+}
+
+void ChromeUserPopulation::InitAsDefaultInstance() {
+}
+
+ChromeUserPopulation::ChromeUserPopulation(const ChromeUserPopulation& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ChromeUserPopulation)
+}
+
+void ChromeUserPopulation::SharedCtor() {
+  _cached_size_ = 0;
+  user_population_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChromeUserPopulation::~ChromeUserPopulation() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ChromeUserPopulation)
+  SharedDtor();
+}
+
+void ChromeUserPopulation::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ChromeUserPopulation::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ChromeUserPopulation& ChromeUserPopulation::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ChromeUserPopulation* ChromeUserPopulation::default_instance_ = NULL;
+
+ChromeUserPopulation* ChromeUserPopulation::New() const {
+  return new ChromeUserPopulation;
+}
+
+void ChromeUserPopulation::Clear() {
+  user_population_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ChromeUserPopulation::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ChromeUserPopulation)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .safe_browsing.ChromeUserPopulation.UserPopulation user_population = 1;
+      case 1: {
+        if (tag == 8) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ChromeUserPopulation_UserPopulation_IsValid(value)) {
+            set_user_population(static_cast< ::safe_browsing::ChromeUserPopulation_UserPopulation >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ChromeUserPopulation)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ChromeUserPopulation)
+  return false;
+#undef DO_
+}
+
+void ChromeUserPopulation::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ChromeUserPopulation)
+  // optional .safe_browsing.ChromeUserPopulation.UserPopulation user_population = 1;
+  if (has_user_population()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->user_population(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ChromeUserPopulation)
+}
+
+int ChromeUserPopulation::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .safe_browsing.ChromeUserPopulation.UserPopulation user_population = 1;
+    if (has_user_population()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->user_population());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChromeUserPopulation::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ChromeUserPopulation*>(&from));
+}
+
+void ChromeUserPopulation::MergeFrom(const ChromeUserPopulation& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_user_population()) {
+      set_user_population(from.user_population());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ChromeUserPopulation::CopyFrom(const ChromeUserPopulation& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChromeUserPopulation::IsInitialized() const {
+
+  return true;
+}
+
+void ChromeUserPopulation::Swap(ChromeUserPopulation* other) {
+  if (other != this) {
+    std::swap(user_population_, other->user_population_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ChromeUserPopulation::GetTypeName() const {
+  return "safe_browsing.ChromeUserPopulation";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClientPhishingRequest_Feature::kNameFieldNumber;
+const int ClientPhishingRequest_Feature::kValueFieldNumber;
+#endif  // !_MSC_VER
+
+ClientPhishingRequest_Feature::ClientPhishingRequest_Feature()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientPhishingRequest.Feature)
+}
+
+void ClientPhishingRequest_Feature::InitAsDefaultInstance() {
+}
+
+ClientPhishingRequest_Feature::ClientPhishingRequest_Feature(const ClientPhishingRequest_Feature& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientPhishingRequest.Feature)
+}
+
+void ClientPhishingRequest_Feature::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  value_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientPhishingRequest_Feature::~ClientPhishingRequest_Feature() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientPhishingRequest.Feature)
+  SharedDtor();
+}
+
+void ClientPhishingRequest_Feature::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientPhishingRequest_Feature::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientPhishingRequest_Feature& ClientPhishingRequest_Feature::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientPhishingRequest_Feature* ClientPhishingRequest_Feature::default_instance_ = NULL;
+
+ClientPhishingRequest_Feature* ClientPhishingRequest_Feature::New() const {
+  return new ClientPhishingRequest_Feature;
+}
+
+void ClientPhishingRequest_Feature::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    value_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientPhishingRequest_Feature::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientPhishingRequest.Feature)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string name = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(17)) goto parse_value;
+        break;
+      }
+
+      // required double value = 2;
+      case 2: {
+        if (tag == 17) {
+         parse_value:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &value_)));
+          set_has_value();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientPhishingRequest.Feature)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientPhishingRequest.Feature)
+  return false;
+#undef DO_
+}
+
+void ClientPhishingRequest_Feature::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientPhishingRequest.Feature)
+  // required string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->name(), output);
+  }
+
+  // required double value = 2;
+  if (has_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->value(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientPhishingRequest.Feature)
+}
+
+int ClientPhishingRequest_Feature::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string name = 1;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // required double value = 2;
+    if (has_value()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientPhishingRequest_Feature::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientPhishingRequest_Feature*>(&from));
+}
+
+void ClientPhishingRequest_Feature::MergeFrom(const ClientPhishingRequest_Feature& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_value()) {
+      set_value(from.value());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientPhishingRequest_Feature::CopyFrom(const ClientPhishingRequest_Feature& from) {
+  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::Swap(ClientPhishingRequest_Feature* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    std::swap(value_, other->value_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientPhishingRequest_Feature::GetTypeName() const {
+  return "safe_browsing.ClientPhishingRequest.Feature";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientPhishingRequest::kUrlFieldNumber;
+const int ClientPhishingRequest::kOBSOLETEHashPrefixFieldNumber;
+const int ClientPhishingRequest::kClientScoreFieldNumber;
+const int ClientPhishingRequest::kIsPhishingFieldNumber;
+const int ClientPhishingRequest::kFeatureMapFieldNumber;
+const int ClientPhishingRequest::kModelVersionFieldNumber;
+const int ClientPhishingRequest::kNonModelFeatureMapFieldNumber;
+const int ClientPhishingRequest::kOBSOLETEReferrerUrlFieldNumber;
+const int ClientPhishingRequest::kShingleHashesFieldNumber;
+const int ClientPhishingRequest::kModelFilenameFieldNumber;
+const int ClientPhishingRequest::kPopulationFieldNumber;
+#endif  // !_MSC_VER
+
+ClientPhishingRequest::ClientPhishingRequest()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientPhishingRequest)
+}
+
+void ClientPhishingRequest::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  population_ = const_cast< ::safe_browsing::ChromeUserPopulation*>(
+      ::safe_browsing::ChromeUserPopulation::internal_default_instance());
+#else
+  population_ = const_cast< ::safe_browsing::ChromeUserPopulation*>(&::safe_browsing::ChromeUserPopulation::default_instance());
+#endif
+}
+
+ClientPhishingRequest::ClientPhishingRequest(const ClientPhishingRequest& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientPhishingRequest)
+}
+
+void ClientPhishingRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  obsolete_hash_prefix_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  client_score_ = 0;
+  is_phishing_ = false;
+  model_version_ = 0;
+  obsolete_referrer_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  model_filename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  population_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientPhishingRequest::~ClientPhishingRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientPhishingRequest)
+  SharedDtor();
+}
+
+void ClientPhishingRequest::SharedDtor() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (obsolete_hash_prefix_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete obsolete_hash_prefix_;
+  }
+  if (obsolete_referrer_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete obsolete_referrer_url_;
+  }
+  if (model_filename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete model_filename_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete population_;
+  }
+}
+
+void ClientPhishingRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientPhishingRequest& ClientPhishingRequest::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientPhishingRequest* ClientPhishingRequest::default_instance_ = NULL;
+
+ClientPhishingRequest* ClientPhishingRequest::New() const {
+  return new ClientPhishingRequest;
+}
+
+void ClientPhishingRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClientPhishingRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 175) {
+    ZR_(client_score_, is_phishing_);
+    if (has_url()) {
+      if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_->clear();
+      }
+    }
+    if (has_obsolete_hash_prefix()) {
+      if (obsolete_hash_prefix_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        obsolete_hash_prefix_->clear();
+      }
+    }
+    model_version_ = 0;
+    if (has_obsolete_referrer_url()) {
+      if (obsolete_referrer_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        obsolete_referrer_url_->clear();
+      }
+    }
+  }
+  if (_has_bits_[8 / 32] & 1536) {
+    if (has_model_filename()) {
+      if (model_filename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        model_filename_->clear();
+      }
+    }
+    if (has_population()) {
+      if (population_ != NULL) population_->::safe_browsing::ChromeUserPopulation::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  feature_map_.Clear();
+  non_model_feature_map_.Clear();
+  shingle_hashes_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientPhishingRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientPhishingRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string url = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(21)) goto parse_client_score;
+        break;
+      }
+
+      // required float client_score = 2;
+      case 2: {
+        if (tag == 21) {
+         parse_client_score:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &client_score_)));
+          set_has_client_score();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_is_phishing;
+        break;
+      }
+
+      // optional bool is_phishing = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_is_phishing:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_phishing_)));
+          set_has_is_phishing();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_feature_map;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_feature_map:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_feature_map()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_feature_map;
+        if (input->ExpectTag(48)) goto parse_model_version;
+        break;
+      }
+
+      // optional int32 model_version = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_model_version:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &model_version_)));
+          set_has_model_version();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_non_model_feature_map;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientPhishingRequest.Feature non_model_feature_map = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_non_model_feature_map:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_non_model_feature_map()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_non_model_feature_map;
+        if (input->ExpectTag(74)) goto parse_OBSOLETE_referrer_url;
+        break;
+      }
+
+      // optional string OBSOLETE_referrer_url = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_OBSOLETE_referrer_url:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_obsolete_referrer_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_OBSOLETE_hash_prefix;
+        break;
+      }
+
+      // optional bytes OBSOLETE_hash_prefix = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_OBSOLETE_hash_prefix:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_obsolete_hash_prefix()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(98)) goto parse_shingle_hashes;
+        break;
+      }
+
+      // repeated uint32 shingle_hashes = 12 [packed = true];
+      case 12: {
+        if (tag == 98) {
+         parse_shingle_hashes:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_shingle_hashes())));
+        } else if (tag == 96) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 98, input, this->mutable_shingle_hashes())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(106)) goto parse_model_filename;
+        break;
+      }
+
+      // optional string model_filename = 13;
+      case 13: {
+        if (tag == 106) {
+         parse_model_filename:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_model_filename()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(114)) goto parse_population;
+        break;
+      }
+
+      // optional .safe_browsing.ChromeUserPopulation population = 14;
+      case 14: {
+        if (tag == 114) {
+         parse_population:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_population()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientPhishingRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientPhishingRequest)
+  return false;
+#undef DO_
+}
+
+void ClientPhishingRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientPhishingRequest)
+  // optional string url = 1;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->url(), output);
+  }
+
+  // required float client_score = 2;
+  if (has_client_score()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->client_score(), output);
+  }
+
+  // optional bool is_phishing = 4;
+  if (has_is_phishing()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_phishing(), output);
+  }
+
+  // repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5;
+  for (int i = 0; i < this->feature_map_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      5, this->feature_map(i), output);
+  }
+
+  // optional int32 model_version = 6;
+  if (has_model_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->model_version(), output);
+  }
+
+  // repeated .safe_browsing.ClientPhishingRequest.Feature non_model_feature_map = 8;
+  for (int i = 0; i < this->non_model_feature_map_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      8, this->non_model_feature_map(i), output);
+  }
+
+  // optional string OBSOLETE_referrer_url = 9;
+  if (has_obsolete_referrer_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      9, this->obsolete_referrer_url(), output);
+  }
+
+  // optional bytes OBSOLETE_hash_prefix = 10;
+  if (has_obsolete_hash_prefix()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      10, this->obsolete_hash_prefix(), output);
+  }
+
+  // repeated uint32 shingle_hashes = 12 [packed = true];
+  if (this->shingle_hashes_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(12, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_shingle_hashes_cached_byte_size_);
+  }
+  for (int i = 0; i < this->shingle_hashes_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->shingle_hashes(i), output);
+  }
+
+  // optional string model_filename = 13;
+  if (has_model_filename()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      13, this->model_filename(), output);
+  }
+
+  // optional .safe_browsing.ChromeUserPopulation population = 14;
+  if (has_population()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      14, this->population(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientPhishingRequest)
+}
+
+int ClientPhishingRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string url = 1;
+    if (has_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->url());
+    }
+
+    // optional bytes OBSOLETE_hash_prefix = 10;
+    if (has_obsolete_hash_prefix()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->obsolete_hash_prefix());
+    }
+
+    // required float client_score = 2;
+    if (has_client_score()) {
+      total_size += 1 + 4;
+    }
+
+    // optional bool is_phishing = 4;
+    if (has_is_phishing()) {
+      total_size += 1 + 1;
+    }
+
+    // optional int32 model_version = 6;
+    if (has_model_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->model_version());
+    }
+
+    // optional string OBSOLETE_referrer_url = 9;
+    if (has_obsolete_referrer_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->obsolete_referrer_url());
+    }
+
+  }
+  if (_has_bits_[9 / 32] & (0xffu << (9 % 32))) {
+    // optional string model_filename = 13;
+    if (has_model_filename()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->model_filename());
+    }
+
+    // optional .safe_browsing.ChromeUserPopulation population = 14;
+    if (has_population()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->population());
+    }
+
+  }
+  // repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5;
+  total_size += 1 * this->feature_map_size();
+  for (int i = 0; i < this->feature_map_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->feature_map(i));
+  }
+
+  // repeated .safe_browsing.ClientPhishingRequest.Feature non_model_feature_map = 8;
+  total_size += 1 * this->non_model_feature_map_size();
+  for (int i = 0; i < this->non_model_feature_map_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->non_model_feature_map(i));
+  }
+
+  // repeated uint32 shingle_hashes = 12 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->shingle_hashes_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->shingle_hashes(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _shingle_hashes_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientPhishingRequest::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientPhishingRequest*>(&from));
+}
+
+void ClientPhishingRequest::MergeFrom(const ClientPhishingRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  feature_map_.MergeFrom(from.feature_map_);
+  non_model_feature_map_.MergeFrom(from.non_model_feature_map_);
+  shingle_hashes_.MergeFrom(from.shingle_hashes_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_url()) {
+      set_url(from.url());
+    }
+    if (from.has_obsolete_hash_prefix()) {
+      set_obsolete_hash_prefix(from.obsolete_hash_prefix());
+    }
+    if (from.has_client_score()) {
+      set_client_score(from.client_score());
+    }
+    if (from.has_is_phishing()) {
+      set_is_phishing(from.is_phishing());
+    }
+    if (from.has_model_version()) {
+      set_model_version(from.model_version());
+    }
+    if (from.has_obsolete_referrer_url()) {
+      set_obsolete_referrer_url(from.obsolete_referrer_url());
+    }
+  }
+  if (from._has_bits_[9 / 32] & (0xffu << (9 % 32))) {
+    if (from.has_model_filename()) {
+      set_model_filename(from.model_filename());
+    }
+    if (from.has_population()) {
+      mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(from.population());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientPhishingRequest::CopyFrom(const ClientPhishingRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientPhishingRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000004) != 0x00000004) return false;
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->feature_map())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->non_model_feature_map())) return false;
+  return true;
+}
+
+void ClientPhishingRequest::Swap(ClientPhishingRequest* other) {
+  if (other != this) {
+    std::swap(url_, other->url_);
+    std::swap(obsolete_hash_prefix_, other->obsolete_hash_prefix_);
+    std::swap(client_score_, other->client_score_);
+    std::swap(is_phishing_, other->is_phishing_);
+    feature_map_.Swap(&other->feature_map_);
+    std::swap(model_version_, other->model_version_);
+    non_model_feature_map_.Swap(&other->non_model_feature_map_);
+    std::swap(obsolete_referrer_url_, other->obsolete_referrer_url_);
+    shingle_hashes_.Swap(&other->shingle_hashes_);
+    std::swap(model_filename_, other->model_filename_);
+    std::swap(population_, other->population_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientPhishingRequest::GetTypeName() const {
+  return "safe_browsing.ClientPhishingRequest";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClientPhishingResponse::kPhishyFieldNumber;
+const int ClientPhishingResponse::kOBSOLETEWhitelistExpressionFieldNumber;
+#endif  // !_MSC_VER
+
+ClientPhishingResponse::ClientPhishingResponse()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientPhishingResponse)
+}
+
+void ClientPhishingResponse::InitAsDefaultInstance() {
+}
+
+ClientPhishingResponse::ClientPhishingResponse(const ClientPhishingResponse& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientPhishingResponse)
+}
+
+void ClientPhishingResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  phishy_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientPhishingResponse::~ClientPhishingResponse() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientPhishingResponse)
+  SharedDtor();
+}
+
+void ClientPhishingResponse::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientPhishingResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientPhishingResponse& ClientPhishingResponse::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientPhishingResponse* ClientPhishingResponse::default_instance_ = NULL;
+
+ClientPhishingResponse* ClientPhishingResponse::New() const {
+  return new ClientPhishingResponse;
+}
+
+void ClientPhishingResponse::Clear() {
+  phishy_ = false;
+  obsolete_whitelist_expression_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientPhishingResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientPhishingResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required bool phishy = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &phishy_)));
+          set_has_phishy();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_OBSOLETE_whitelist_expression;
+        break;
+      }
+
+      // repeated string OBSOLETE_whitelist_expression = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_OBSOLETE_whitelist_expression:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_obsolete_whitelist_expression()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_OBSOLETE_whitelist_expression;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientPhishingResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientPhishingResponse)
+  return false;
+#undef DO_
+}
+
+void ClientPhishingResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientPhishingResponse)
+  // required bool phishy = 1;
+  if (has_phishy()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->phishy(), output);
+  }
+
+  // repeated string OBSOLETE_whitelist_expression = 2;
+  for (int i = 0; i < this->obsolete_whitelist_expression_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->obsolete_whitelist_expression(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientPhishingResponse)
+}
+
+int ClientPhishingResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required bool phishy = 1;
+    if (has_phishy()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated string OBSOLETE_whitelist_expression = 2;
+  total_size += 1 * this->obsolete_whitelist_expression_size();
+  for (int i = 0; i < this->obsolete_whitelist_expression_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->obsolete_whitelist_expression(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientPhishingResponse::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientPhishingResponse*>(&from));
+}
+
+void ClientPhishingResponse::MergeFrom(const ClientPhishingResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  obsolete_whitelist_expression_.MergeFrom(from.obsolete_whitelist_expression_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_phishy()) {
+      set_phishy(from.phishy());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientPhishingResponse::CopyFrom(const ClientPhishingResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientPhishingResponse::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void ClientPhishingResponse::Swap(ClientPhishingResponse* other) {
+  if (other != this) {
+    std::swap(phishy_, other->phishy_);
+    obsolete_whitelist_expression_.Swap(&other->obsolete_whitelist_expression_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientPhishingResponse::GetTypeName() const {
+  return "safe_browsing.ClientPhishingResponse";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClientMalwareRequest_UrlInfo::kIpFieldNumber;
+const int ClientMalwareRequest_UrlInfo::kUrlFieldNumber;
+const int ClientMalwareRequest_UrlInfo::kMethodFieldNumber;
+const int ClientMalwareRequest_UrlInfo::kReferrerFieldNumber;
+const int ClientMalwareRequest_UrlInfo::kResourceTypeFieldNumber;
+#endif  // !_MSC_VER
+
+ClientMalwareRequest_UrlInfo::ClientMalwareRequest_UrlInfo()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientMalwareRequest.UrlInfo)
+}
+
+void ClientMalwareRequest_UrlInfo::InitAsDefaultInstance() {
+}
+
+ClientMalwareRequest_UrlInfo::ClientMalwareRequest_UrlInfo(const ClientMalwareRequest_UrlInfo& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientMalwareRequest.UrlInfo)
+}
+
+void ClientMalwareRequest_UrlInfo::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  method_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  resource_type_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientMalwareRequest_UrlInfo::~ClientMalwareRequest_UrlInfo() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientMalwareRequest.UrlInfo)
+  SharedDtor();
+}
+
+void ClientMalwareRequest_UrlInfo::SharedDtor() {
+  if (ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete ip_;
+  }
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (method_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete method_;
+  }
+  if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete referrer_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientMalwareRequest_UrlInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientMalwareRequest_UrlInfo& ClientMalwareRequest_UrlInfo::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientMalwareRequest_UrlInfo* ClientMalwareRequest_UrlInfo::default_instance_ = NULL;
+
+ClientMalwareRequest_UrlInfo* ClientMalwareRequest_UrlInfo::New() const {
+  return new ClientMalwareRequest_UrlInfo;
+}
+
+void ClientMalwareRequest_UrlInfo::Clear() {
+  if (_has_bits_[0 / 32] & 31) {
+    if (has_ip()) {
+      if (ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        ip_->clear();
+      }
+    }
+    if (has_url()) {
+      if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_->clear();
+      }
+    }
+    if (has_method()) {
+      if (method_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        method_->clear();
+      }
+    }
+    if (has_referrer()) {
+      if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        referrer_->clear();
+      }
+    }
+    resource_type_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientMalwareRequest_UrlInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientMalwareRequest.UrlInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string ip = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_ip()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_url;
+        break;
+      }
+
+      // required string url = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_url:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_method;
+        break;
+      }
+
+      // optional string method = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_method:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_method()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_referrer;
+        break;
+      }
+
+      // optional string referrer = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_referrer:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_referrer()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_resource_type;
+        break;
+      }
+
+      // optional int32 resource_type = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_resource_type:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &resource_type_)));
+          set_has_resource_type();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientMalwareRequest.UrlInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientMalwareRequest.UrlInfo)
+  return false;
+#undef DO_
+}
+
+void ClientMalwareRequest_UrlInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientMalwareRequest.UrlInfo)
+  // required string ip = 1;
+  if (has_ip()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->ip(), output);
+  }
+
+  // required string url = 2;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->url(), output);
+  }
+
+  // optional string method = 3;
+  if (has_method()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->method(), output);
+  }
+
+  // optional string referrer = 4;
+  if (has_referrer()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->referrer(), output);
+  }
+
+  // optional int32 resource_type = 5;
+  if (has_resource_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->resource_type(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientMalwareRequest.UrlInfo)
+}
+
+int ClientMalwareRequest_UrlInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string ip = 1;
+    if (has_ip()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->ip());
+    }
+
+    // required string url = 2;
+    if (has_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->url());
+    }
+
+    // optional string method = 3;
+    if (has_method()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->method());
+    }
+
+    // optional string referrer = 4;
+    if (has_referrer()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->referrer());
+    }
+
+    // optional int32 resource_type = 5;
+    if (has_resource_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->resource_type());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientMalwareRequest_UrlInfo::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientMalwareRequest_UrlInfo*>(&from));
+}
+
+void ClientMalwareRequest_UrlInfo::MergeFrom(const ClientMalwareRequest_UrlInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_ip()) {
+      set_ip(from.ip());
+    }
+    if (from.has_url()) {
+      set_url(from.url());
+    }
+    if (from.has_method()) {
+      set_method(from.method());
+    }
+    if (from.has_referrer()) {
+      set_referrer(from.referrer());
+    }
+    if (from.has_resource_type()) {
+      set_resource_type(from.resource_type());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientMalwareRequest_UrlInfo::CopyFrom(const ClientMalwareRequest_UrlInfo& from) {
+  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::Swap(ClientMalwareRequest_UrlInfo* other) {
+  if (other != this) {
+    std::swap(ip_, other->ip_);
+    std::swap(url_, other->url_);
+    std::swap(method_, other->method_);
+    std::swap(referrer_, other->referrer_);
+    std::swap(resource_type_, other->resource_type_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientMalwareRequest_UrlInfo::GetTypeName() const {
+  return "safe_browsing.ClientMalwareRequest.UrlInfo";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientMalwareRequest::kUrlFieldNumber;
+const int ClientMalwareRequest::kReferrerUrlFieldNumber;
+const int ClientMalwareRequest::kBadIpUrlInfoFieldNumber;
+const int ClientMalwareRequest::kPopulationFieldNumber;
+#endif  // !_MSC_VER
+
+ClientMalwareRequest::ClientMalwareRequest()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientMalwareRequest)
+}
+
+void ClientMalwareRequest::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  population_ = const_cast< ::safe_browsing::ChromeUserPopulation*>(
+      ::safe_browsing::ChromeUserPopulation::internal_default_instance());
+#else
+  population_ = const_cast< ::safe_browsing::ChromeUserPopulation*>(&::safe_browsing::ChromeUserPopulation::default_instance());
+#endif
+}
+
+ClientMalwareRequest::ClientMalwareRequest(const ClientMalwareRequest& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientMalwareRequest)
+}
+
+void ClientMalwareRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  referrer_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  population_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientMalwareRequest::~ClientMalwareRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientMalwareRequest)
+  SharedDtor();
+}
+
+void ClientMalwareRequest::SharedDtor() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (referrer_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete referrer_url_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete population_;
+  }
+}
+
+void ClientMalwareRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientMalwareRequest& ClientMalwareRequest::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientMalwareRequest* ClientMalwareRequest::default_instance_ = NULL;
+
+ClientMalwareRequest* ClientMalwareRequest::New() const {
+  return new ClientMalwareRequest;
+}
+
+void ClientMalwareRequest::Clear() {
+  if (_has_bits_[0 / 32] & 11) {
+    if (has_url()) {
+      if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_->clear();
+      }
+    }
+    if (has_referrer_url()) {
+      if (referrer_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        referrer_url_->clear();
+      }
+    }
+    if (has_population()) {
+      if (population_ != NULL) population_->::safe_browsing::ChromeUserPopulation::Clear();
+    }
+  }
+  bad_ip_url_info_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientMalwareRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientMalwareRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string url = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_referrer_url;
+        break;
+      }
+
+      // optional string referrer_url = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_referrer_url:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_referrer_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_bad_ip_url_info;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientMalwareRequest.UrlInfo bad_ip_url_info = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_bad_ip_url_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_bad_ip_url_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_bad_ip_url_info;
+        if (input->ExpectTag(74)) goto parse_population;
+        break;
+      }
+
+      // optional .safe_browsing.ChromeUserPopulation population = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_population:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_population()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientMalwareRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientMalwareRequest)
+  return false;
+#undef DO_
+}
+
+void ClientMalwareRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientMalwareRequest)
+  // required string url = 1;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->url(), output);
+  }
+
+  // optional string referrer_url = 4;
+  if (has_referrer_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->referrer_url(), output);
+  }
+
+  // repeated .safe_browsing.ClientMalwareRequest.UrlInfo bad_ip_url_info = 7;
+  for (int i = 0; i < this->bad_ip_url_info_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      7, this->bad_ip_url_info(i), output);
+  }
+
+  // optional .safe_browsing.ChromeUserPopulation population = 9;
+  if (has_population()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      9, this->population(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientMalwareRequest)
+}
+
+int ClientMalwareRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string url = 1;
+    if (has_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->url());
+    }
+
+    // optional string referrer_url = 4;
+    if (has_referrer_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->referrer_url());
+    }
+
+    // optional .safe_browsing.ChromeUserPopulation population = 9;
+    if (has_population()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->population());
+    }
+
+  }
+  // repeated .safe_browsing.ClientMalwareRequest.UrlInfo bad_ip_url_info = 7;
+  total_size += 1 * this->bad_ip_url_info_size();
+  for (int i = 0; i < this->bad_ip_url_info_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->bad_ip_url_info(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientMalwareRequest::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientMalwareRequest*>(&from));
+}
+
+void ClientMalwareRequest::MergeFrom(const ClientMalwareRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  bad_ip_url_info_.MergeFrom(from.bad_ip_url_info_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_url()) {
+      set_url(from.url());
+    }
+    if (from.has_referrer_url()) {
+      set_referrer_url(from.referrer_url());
+    }
+    if (from.has_population()) {
+      mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(from.population());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientMalwareRequest::CopyFrom(const ClientMalwareRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientMalwareRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->bad_ip_url_info())) return false;
+  return true;
+}
+
+void ClientMalwareRequest::Swap(ClientMalwareRequest* other) {
+  if (other != this) {
+    std::swap(url_, other->url_);
+    std::swap(referrer_url_, other->referrer_url_);
+    bad_ip_url_info_.Swap(&other->bad_ip_url_info_);
+    std::swap(population_, other->population_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientMalwareRequest::GetTypeName() const {
+  return "safe_browsing.ClientMalwareRequest";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClientMalwareResponse::kBlacklistFieldNumber;
+const int ClientMalwareResponse::kBadIpFieldNumber;
+const int ClientMalwareResponse::kBadUrlFieldNumber;
+#endif  // !_MSC_VER
+
+ClientMalwareResponse::ClientMalwareResponse()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientMalwareResponse)
+}
+
+void ClientMalwareResponse::InitAsDefaultInstance() {
+}
+
+ClientMalwareResponse::ClientMalwareResponse(const ClientMalwareResponse& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientMalwareResponse)
+}
+
+void ClientMalwareResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  blacklist_ = false;
+  bad_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  bad_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientMalwareResponse::~ClientMalwareResponse() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientMalwareResponse)
+  SharedDtor();
+}
+
+void ClientMalwareResponse::SharedDtor() {
+  if (bad_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete bad_ip_;
+  }
+  if (bad_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete bad_url_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientMalwareResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientMalwareResponse& ClientMalwareResponse::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientMalwareResponse* ClientMalwareResponse::default_instance_ = NULL;
+
+ClientMalwareResponse* ClientMalwareResponse::New() const {
+  return new ClientMalwareResponse;
+}
+
+void ClientMalwareResponse::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    blacklist_ = false;
+    if (has_bad_ip()) {
+      if (bad_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        bad_ip_->clear();
+      }
+    }
+    if (has_bad_url()) {
+      if (bad_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        bad_url_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientMalwareResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientMalwareResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required bool blacklist = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &blacklist_)));
+          set_has_blacklist();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_bad_ip;
+        break;
+      }
+
+      // optional string bad_ip = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_bad_ip:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_bad_ip()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_bad_url;
+        break;
+      }
+
+      // optional string bad_url = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_bad_url:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_bad_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientMalwareResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientMalwareResponse)
+  return false;
+#undef DO_
+}
+
+void ClientMalwareResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientMalwareResponse)
+  // required bool blacklist = 1;
+  if (has_blacklist()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->blacklist(), output);
+  }
+
+  // optional string bad_ip = 2;
+  if (has_bad_ip()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->bad_ip(), output);
+  }
+
+  // optional string bad_url = 3;
+  if (has_bad_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->bad_url(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientMalwareResponse)
+}
+
+int ClientMalwareResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required bool blacklist = 1;
+    if (has_blacklist()) {
+      total_size += 1 + 1;
+    }
+
+    // optional string bad_ip = 2;
+    if (has_bad_ip()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->bad_ip());
+    }
+
+    // optional string bad_url = 3;
+    if (has_bad_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->bad_url());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientMalwareResponse::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientMalwareResponse*>(&from));
+}
+
+void ClientMalwareResponse::MergeFrom(const ClientMalwareResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_blacklist()) {
+      set_blacklist(from.blacklist());
+    }
+    if (from.has_bad_ip()) {
+      set_bad_ip(from.bad_ip());
+    }
+    if (from.has_bad_url()) {
+      set_bad_url(from.bad_url());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientMalwareResponse::CopyFrom(const ClientMalwareResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientMalwareResponse::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void ClientMalwareResponse::Swap(ClientMalwareResponse* other) {
+  if (other != this) {
+    std::swap(blacklist_, other->blacklist_);
+    std::swap(bad_ip_, other->bad_ip_);
+    std::swap(bad_url_, other->bad_url_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientMalwareResponse::GetTypeName() const {
+  return "safe_browsing.ClientMalwareResponse";
+}
+
+
+// ===================================================================
+
+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;
+  }
+}
+
+#ifndef _MSC_VER
+const ClientDownloadRequest_ResourceType ClientDownloadRequest::DOWNLOAD_URL;
+const ClientDownloadRequest_ResourceType ClientDownloadRequest::DOWNLOAD_REDIRECT;
+const ClientDownloadRequest_ResourceType ClientDownloadRequest::TAB_URL;
+const ClientDownloadRequest_ResourceType ClientDownloadRequest::TAB_REDIRECT;
+const ClientDownloadRequest_ResourceType ClientDownloadRequest::PPAPI_DOCUMENT;
+const ClientDownloadRequest_ResourceType ClientDownloadRequest::PPAPI_PLUGIN;
+const ClientDownloadRequest_ResourceType ClientDownloadRequest::ResourceType_MIN;
+const ClientDownloadRequest_ResourceType ClientDownloadRequest::ResourceType_MAX;
+const int ClientDownloadRequest::ResourceType_ARRAYSIZE;
+#endif  // _MSC_VER
+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;
+  }
+}
+
+#ifndef _MSC_VER
+const ClientDownloadRequest_DownloadType ClientDownloadRequest::WIN_EXECUTABLE;
+const ClientDownloadRequest_DownloadType ClientDownloadRequest::CHROME_EXTENSION;
+const ClientDownloadRequest_DownloadType ClientDownloadRequest::ANDROID_APK;
+const ClientDownloadRequest_DownloadType ClientDownloadRequest::ZIPPED_EXECUTABLE;
+const ClientDownloadRequest_DownloadType ClientDownloadRequest::MAC_EXECUTABLE;
+const ClientDownloadRequest_DownloadType ClientDownloadRequest::ZIPPED_ARCHIVE;
+const ClientDownloadRequest_DownloadType ClientDownloadRequest::ARCHIVE;
+const ClientDownloadRequest_DownloadType ClientDownloadRequest::INVALID_ZIP;
+const ClientDownloadRequest_DownloadType ClientDownloadRequest::INVALID_MAC_ARCHIVE;
+const ClientDownloadRequest_DownloadType ClientDownloadRequest::PPAPI_SAVE_REQUEST;
+const ClientDownloadRequest_DownloadType ClientDownloadRequest::SAMPLED_UNSUPPORTED_FILE;
+const ClientDownloadRequest_DownloadType ClientDownloadRequest::DownloadType_MIN;
+const ClientDownloadRequest_DownloadType ClientDownloadRequest::DownloadType_MAX;
+const int ClientDownloadRequest::DownloadType_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ClientDownloadRequest_Digests::kSha256FieldNumber;
+const int ClientDownloadRequest_Digests::kSha1FieldNumber;
+const int ClientDownloadRequest_Digests::kMd5FieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest_Digests::ClientDownloadRequest_Digests()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.Digests)
+}
+
+void ClientDownloadRequest_Digests::InitAsDefaultInstance() {
+}
+
+ClientDownloadRequest_Digests::ClientDownloadRequest_Digests(const ClientDownloadRequest_Digests& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.Digests)
+}
+
+void ClientDownloadRequest_Digests::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  sha256_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  sha1_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  md5_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest_Digests::~ClientDownloadRequest_Digests() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.Digests)
+  SharedDtor();
+}
+
+void ClientDownloadRequest_Digests::SharedDtor() {
+  if (sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete sha256_;
+  }
+  if (sha1_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete sha1_;
+  }
+  if (md5_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete md5_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientDownloadRequest_Digests::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest_Digests& ClientDownloadRequest_Digests::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest_Digests* ClientDownloadRequest_Digests::default_instance_ = NULL;
+
+ClientDownloadRequest_Digests* ClientDownloadRequest_Digests::New() const {
+  return new ClientDownloadRequest_Digests;
+}
+
+void ClientDownloadRequest_Digests::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_sha256()) {
+      if (sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        sha256_->clear();
+      }
+    }
+    if (has_sha1()) {
+      if (sha1_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        sha1_->clear();
+      }
+    }
+    if (has_md5()) {
+      if (md5_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        md5_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest_Digests::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest.Digests)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes sha256 = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_sha256()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_sha1;
+        break;
+      }
+
+      // optional bytes sha1 = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_sha1:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_sha1()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_md5;
+        break;
+      }
+
+      // optional bytes md5 = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_md5:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_md5()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest.Digests)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest.Digests)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest_Digests::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest.Digests)
+  // optional bytes sha256 = 1;
+  if (has_sha256()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->sha256(), output);
+  }
+
+  // optional bytes sha1 = 2;
+  if (has_sha1()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->sha1(), output);
+  }
+
+  // optional bytes md5 = 3;
+  if (has_md5()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->md5(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest.Digests)
+}
+
+int ClientDownloadRequest_Digests::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes sha256 = 1;
+    if (has_sha256()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->sha256());
+    }
+
+    // optional bytes sha1 = 2;
+    if (has_sha1()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->sha1());
+    }
+
+    // optional bytes md5 = 3;
+    if (has_md5()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->md5());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest_Digests::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest_Digests*>(&from));
+}
+
+void ClientDownloadRequest_Digests::MergeFrom(const ClientDownloadRequest_Digests& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_sha256()) {
+      set_sha256(from.sha256());
+    }
+    if (from.has_sha1()) {
+      set_sha1(from.sha1());
+    }
+    if (from.has_md5()) {
+      set_md5(from.md5());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest_Digests::CopyFrom(const ClientDownloadRequest_Digests& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_Digests::IsInitialized() const {
+
+  return true;
+}
+
+void ClientDownloadRequest_Digests::Swap(ClientDownloadRequest_Digests* other) {
+  if (other != this) {
+    std::swap(sha256_, other->sha256_);
+    std::swap(sha1_, other->sha1_);
+    std::swap(md5_, other->md5_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest_Digests::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.Digests";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadRequest_Resource::kUrlFieldNumber;
+const int ClientDownloadRequest_Resource::kTypeFieldNumber;
+const int ClientDownloadRequest_Resource::kRemoteIpFieldNumber;
+const int ClientDownloadRequest_Resource::kReferrerFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest_Resource::ClientDownloadRequest_Resource()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.Resource)
+}
+
+void ClientDownloadRequest_Resource::InitAsDefaultInstance() {
+}
+
+ClientDownloadRequest_Resource::ClientDownloadRequest_Resource(const ClientDownloadRequest_Resource& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.Resource)
+}
+
+void ClientDownloadRequest_Resource::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  type_ = 0;
+  remote_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest_Resource::~ClientDownloadRequest_Resource() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.Resource)
+  SharedDtor();
+}
+
+void ClientDownloadRequest_Resource::SharedDtor() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete remote_ip_;
+  }
+  if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete referrer_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientDownloadRequest_Resource::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest_Resource& ClientDownloadRequest_Resource::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest_Resource* ClientDownloadRequest_Resource::default_instance_ = NULL;
+
+ClientDownloadRequest_Resource* ClientDownloadRequest_Resource::New() const {
+  return new ClientDownloadRequest_Resource;
+}
+
+void ClientDownloadRequest_Resource::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_url()) {
+      if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_->clear();
+      }
+    }
+    type_ = 0;
+    if (has_remote_ip()) {
+      if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        remote_ip_->clear();
+      }
+    }
+    if (has_referrer()) {
+      if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        referrer_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest_Resource::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest.Resource)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string url = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_type;
+        break;
+      }
+
+      // required .safe_browsing.ClientDownloadRequest.ResourceType type = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientDownloadRequest_ResourceType_IsValid(value)) {
+            set_type(static_cast< ::safe_browsing::ClientDownloadRequest_ResourceType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_remote_ip;
+        break;
+      }
+
+      // optional bytes remote_ip = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_remote_ip:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_remote_ip()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_referrer;
+        break;
+      }
+
+      // optional string referrer = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_referrer:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_referrer()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest.Resource)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest.Resource)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest_Resource::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest.Resource)
+  // required string url = 1;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->url(), output);
+  }
+
+  // required .safe_browsing.ClientDownloadRequest.ResourceType type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->type(), output);
+  }
+
+  // optional bytes remote_ip = 3;
+  if (has_remote_ip()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->remote_ip(), output);
+  }
+
+  // optional string referrer = 4;
+  if (has_referrer()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->referrer(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest.Resource)
+}
+
+int ClientDownloadRequest_Resource::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string url = 1;
+    if (has_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->url());
+    }
+
+    // required .safe_browsing.ClientDownloadRequest.ResourceType type = 2;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
+    }
+
+    // optional bytes remote_ip = 3;
+    if (has_remote_ip()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->remote_ip());
+    }
+
+    // optional string referrer = 4;
+    if (has_referrer()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->referrer());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest_Resource::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest_Resource*>(&from));
+}
+
+void ClientDownloadRequest_Resource::MergeFrom(const ClientDownloadRequest_Resource& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_url()) {
+      set_url(from.url());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_remote_ip()) {
+      set_remote_ip(from.remote_ip());
+    }
+    if (from.has_referrer()) {
+      set_referrer(from.referrer());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest_Resource::CopyFrom(const ClientDownloadRequest_Resource& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_Resource::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  return true;
+}
+
+void ClientDownloadRequest_Resource::Swap(ClientDownloadRequest_Resource* other) {
+  if (other != this) {
+    std::swap(url_, other->url_);
+    std::swap(type_, other->type_);
+    std::swap(remote_ip_, other->remote_ip_);
+    std::swap(referrer_, other->referrer_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest_Resource::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.Resource";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadRequest_CertificateChain_Element::kCertificateFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest_CertificateChain_Element::ClientDownloadRequest_CertificateChain_Element()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+}
+
+void ClientDownloadRequest_CertificateChain_Element::InitAsDefaultInstance() {
+}
+
+ClientDownloadRequest_CertificateChain_Element::ClientDownloadRequest_CertificateChain_Element(const ClientDownloadRequest_CertificateChain_Element& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+}
+
+void ClientDownloadRequest_CertificateChain_Element::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  certificate_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest_CertificateChain_Element::~ClientDownloadRequest_CertificateChain_Element() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+  SharedDtor();
+}
+
+void ClientDownloadRequest_CertificateChain_Element::SharedDtor() {
+  if (certificate_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete certificate_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientDownloadRequest_CertificateChain_Element::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest_CertificateChain_Element& ClientDownloadRequest_CertificateChain_Element::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest_CertificateChain_Element* ClientDownloadRequest_CertificateChain_Element::default_instance_ = NULL;
+
+ClientDownloadRequest_CertificateChain_Element* ClientDownloadRequest_CertificateChain_Element::New() const {
+  return new ClientDownloadRequest_CertificateChain_Element;
+}
+
+void ClientDownloadRequest_CertificateChain_Element::Clear() {
+  if (has_certificate()) {
+    if (certificate_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      certificate_->clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest_CertificateChain_Element::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes certificate = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_certificate()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest_CertificateChain_Element::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+  // optional bytes certificate = 1;
+  if (has_certificate()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->certificate(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+}
+
+int ClientDownloadRequest_CertificateChain_Element::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes certificate = 1;
+    if (has_certificate()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->certificate());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest_CertificateChain_Element::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest_CertificateChain_Element*>(&from));
+}
+
+void ClientDownloadRequest_CertificateChain_Element::MergeFrom(const ClientDownloadRequest_CertificateChain_Element& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_certificate()) {
+      set_certificate(from.certificate());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest_CertificateChain_Element::CopyFrom(const ClientDownloadRequest_CertificateChain_Element& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_CertificateChain_Element::IsInitialized() const {
+
+  return true;
+}
+
+void ClientDownloadRequest_CertificateChain_Element::Swap(ClientDownloadRequest_CertificateChain_Element* other) {
+  if (other != this) {
+    std::swap(certificate_, other->certificate_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest_CertificateChain_Element::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.CertificateChain.Element";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadRequest_CertificateChain::kElementFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest_CertificateChain::ClientDownloadRequest_CertificateChain()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.CertificateChain)
+}
+
+void ClientDownloadRequest_CertificateChain::InitAsDefaultInstance() {
+}
+
+ClientDownloadRequest_CertificateChain::ClientDownloadRequest_CertificateChain(const ClientDownloadRequest_CertificateChain& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.CertificateChain)
+}
+
+void ClientDownloadRequest_CertificateChain::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest_CertificateChain::~ClientDownloadRequest_CertificateChain() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.CertificateChain)
+  SharedDtor();
+}
+
+void ClientDownloadRequest_CertificateChain::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientDownloadRequest_CertificateChain::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest_CertificateChain& ClientDownloadRequest_CertificateChain::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest_CertificateChain* ClientDownloadRequest_CertificateChain::default_instance_ = NULL;
+
+ClientDownloadRequest_CertificateChain* ClientDownloadRequest_CertificateChain::New() const {
+  return new ClientDownloadRequest_CertificateChain;
+}
+
+void ClientDownloadRequest_CertificateChain::Clear() {
+  element_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest_CertificateChain::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest.CertificateChain)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .safe_browsing.ClientDownloadRequest.CertificateChain.Element element = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_element:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_element()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_element;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest.CertificateChain)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest.CertificateChain)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest_CertificateChain::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest.CertificateChain)
+  // repeated .safe_browsing.ClientDownloadRequest.CertificateChain.Element element = 1;
+  for (int i = 0; i < this->element_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->element(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest.CertificateChain)
+}
+
+int ClientDownloadRequest_CertificateChain::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .safe_browsing.ClientDownloadRequest.CertificateChain.Element element = 1;
+  total_size += 1 * this->element_size();
+  for (int i = 0; i < this->element_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->element(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest_CertificateChain::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest_CertificateChain*>(&from));
+}
+
+void ClientDownloadRequest_CertificateChain::MergeFrom(const ClientDownloadRequest_CertificateChain& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  element_.MergeFrom(from.element_);
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest_CertificateChain::CopyFrom(const ClientDownloadRequest_CertificateChain& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_CertificateChain::IsInitialized() const {
+
+  return true;
+}
+
+void ClientDownloadRequest_CertificateChain::Swap(ClientDownloadRequest_CertificateChain* other) {
+  if (other != this) {
+    element_.Swap(&other->element_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest_CertificateChain::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.CertificateChain";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadRequest_ExtendedAttr::kKeyFieldNumber;
+const int ClientDownloadRequest_ExtendedAttr::kValueFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest_ExtendedAttr::ClientDownloadRequest_ExtendedAttr()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+}
+
+void ClientDownloadRequest_ExtendedAttr::InitAsDefaultInstance() {
+}
+
+ClientDownloadRequest_ExtendedAttr::ClientDownloadRequest_ExtendedAttr(const ClientDownloadRequest_ExtendedAttr& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+}
+
+void ClientDownloadRequest_ExtendedAttr::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest_ExtendedAttr::~ClientDownloadRequest_ExtendedAttr() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+  SharedDtor();
+}
+
+void ClientDownloadRequest_ExtendedAttr::SharedDtor() {
+  if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete key_;
+  }
+  if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete value_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientDownloadRequest_ExtendedAttr::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest_ExtendedAttr& ClientDownloadRequest_ExtendedAttr::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest_ExtendedAttr* ClientDownloadRequest_ExtendedAttr::default_instance_ = NULL;
+
+ClientDownloadRequest_ExtendedAttr* ClientDownloadRequest_ExtendedAttr::New() const {
+  return new ClientDownloadRequest_ExtendedAttr;
+}
+
+void ClientDownloadRequest_ExtendedAttr::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_key()) {
+      if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        key_->clear();
+      }
+    }
+    if (has_value()) {
+      if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        value_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest_ExtendedAttr::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string key = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_key()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_value;
+        break;
+      }
+
+      // optional bytes value = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_value()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest_ExtendedAttr::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+  // required string key = 1;
+  if (has_key()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->key(), output);
+  }
+
+  // optional bytes value = 2;
+  if (has_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->value(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+}
+
+int ClientDownloadRequest_ExtendedAttr::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string key = 1;
+    if (has_key()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->key());
+    }
+
+    // optional bytes value = 2;
+    if (has_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->value());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest_ExtendedAttr::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest_ExtendedAttr*>(&from));
+}
+
+void ClientDownloadRequest_ExtendedAttr::MergeFrom(const ClientDownloadRequest_ExtendedAttr& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_key()) {
+      set_key(from.key());
+    }
+    if (from.has_value()) {
+      set_value(from.value());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest_ExtendedAttr::CopyFrom(const ClientDownloadRequest_ExtendedAttr& from) {
+  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::Swap(ClientDownloadRequest_ExtendedAttr* other) {
+  if (other != this) {
+    std::swap(key_, other->key_);
+    std::swap(value_, other->value_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest_ExtendedAttr::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.ExtendedAttr";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadRequest_SignatureInfo::kCertificateChainFieldNumber;
+const int ClientDownloadRequest_SignatureInfo::kTrustedFieldNumber;
+const int ClientDownloadRequest_SignatureInfo::kSignedDataFieldNumber;
+const int ClientDownloadRequest_SignatureInfo::kXattrFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest_SignatureInfo::ClientDownloadRequest_SignatureInfo()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.SignatureInfo)
+}
+
+void ClientDownloadRequest_SignatureInfo::InitAsDefaultInstance() {
+}
+
+ClientDownloadRequest_SignatureInfo::ClientDownloadRequest_SignatureInfo(const ClientDownloadRequest_SignatureInfo& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.SignatureInfo)
+}
+
+void ClientDownloadRequest_SignatureInfo::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  trusted_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest_SignatureInfo::~ClientDownloadRequest_SignatureInfo() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.SignatureInfo)
+  SharedDtor();
+}
+
+void ClientDownloadRequest_SignatureInfo::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientDownloadRequest_SignatureInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest_SignatureInfo& ClientDownloadRequest_SignatureInfo::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest_SignatureInfo* ClientDownloadRequest_SignatureInfo::default_instance_ = NULL;
+
+ClientDownloadRequest_SignatureInfo* ClientDownloadRequest_SignatureInfo::New() const {
+  return new ClientDownloadRequest_SignatureInfo;
+}
+
+void ClientDownloadRequest_SignatureInfo::Clear() {
+  trusted_ = false;
+  certificate_chain_.Clear();
+  signed_data_.Clear();
+  xattr_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest_SignatureInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest.SignatureInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_certificate_chain:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_certificate_chain()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_certificate_chain;
+        if (input->ExpectTag(16)) goto parse_trusted;
+        break;
+      }
+
+      // optional bool trusted = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_trusted:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &trusted_)));
+          set_has_trusted();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_signed_data;
+        break;
+      }
+
+      // repeated bytes signed_data = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_signed_data:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->add_signed_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_signed_data;
+        if (input->ExpectTag(34)) goto parse_xattr;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientDownloadRequest.ExtendedAttr xattr = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_xattr:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_xattr()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_xattr;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest.SignatureInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest.SignatureInfo)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest_SignatureInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest.SignatureInfo)
+  // repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1;
+  for (int i = 0; i < this->certificate_chain_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->certificate_chain(i), output);
+  }
+
+  // optional bool trusted = 2;
+  if (has_trusted()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->trusted(), output);
+  }
+
+  // repeated bytes signed_data = 3;
+  for (int i = 0; i < this->signed_data_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytes(
+      3, this->signed_data(i), output);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.ExtendedAttr xattr = 4;
+  for (int i = 0; i < this->xattr_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->xattr(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest.SignatureInfo)
+}
+
+int ClientDownloadRequest_SignatureInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional bool trusted = 2;
+    if (has_trusted()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1;
+  total_size += 1 * this->certificate_chain_size();
+  for (int i = 0; i < this->certificate_chain_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->certificate_chain(i));
+  }
+
+  // repeated bytes signed_data = 3;
+  total_size += 1 * this->signed_data_size();
+  for (int i = 0; i < this->signed_data_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
+      this->signed_data(i));
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.ExtendedAttr xattr = 4;
+  total_size += 1 * this->xattr_size();
+  for (int i = 0; i < this->xattr_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->xattr(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest_SignatureInfo::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest_SignatureInfo*>(&from));
+}
+
+void ClientDownloadRequest_SignatureInfo::MergeFrom(const ClientDownloadRequest_SignatureInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  certificate_chain_.MergeFrom(from.certificate_chain_);
+  signed_data_.MergeFrom(from.signed_data_);
+  xattr_.MergeFrom(from.xattr_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_trusted()) {
+      set_trusted(from.trusted());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest_SignatureInfo::CopyFrom(const ClientDownloadRequest_SignatureInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_SignatureInfo::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->xattr())) return false;
+  return true;
+}
+
+void ClientDownloadRequest_SignatureInfo::Swap(ClientDownloadRequest_SignatureInfo* other) {
+  if (other != this) {
+    certificate_chain_.Swap(&other->certificate_chain_);
+    std::swap(trusted_, other->trusted_);
+    signed_data_.Swap(&other->signed_data_);
+    xattr_.Swap(&other->xattr_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest_SignatureInfo::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.SignatureInfo";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadRequest_PEImageHeaders_DebugData::kDirectoryEntryFieldNumber;
+const int ClientDownloadRequest_PEImageHeaders_DebugData::kRawDataFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest_PEImageHeaders_DebugData::ClientDownloadRequest_PEImageHeaders_DebugData()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::InitAsDefaultInstance() {
+}
+
+ClientDownloadRequest_PEImageHeaders_DebugData::ClientDownloadRequest_PEImageHeaders_DebugData(const ClientDownloadRequest_PEImageHeaders_DebugData& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  directory_entry_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  raw_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest_PEImageHeaders_DebugData::~ClientDownloadRequest_PEImageHeaders_DebugData() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+  SharedDtor();
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::SharedDtor() {
+  if (directory_entry_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete directory_entry_;
+  }
+  if (raw_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete raw_data_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest_PEImageHeaders_DebugData& ClientDownloadRequest_PEImageHeaders_DebugData::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest_PEImageHeaders_DebugData* ClientDownloadRequest_PEImageHeaders_DebugData::default_instance_ = NULL;
+
+ClientDownloadRequest_PEImageHeaders_DebugData* ClientDownloadRequest_PEImageHeaders_DebugData::New() const {
+  return new ClientDownloadRequest_PEImageHeaders_DebugData;
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_directory_entry()) {
+      if (directory_entry_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        directory_entry_->clear();
+      }
+    }
+    if (has_raw_data()) {
+      if (raw_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        raw_data_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest_PEImageHeaders_DebugData::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes directory_entry = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_directory_entry()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_raw_data;
+        break;
+      }
+
+      // optional bytes raw_data = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_raw_data:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_raw_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+  // optional bytes directory_entry = 1;
+  if (has_directory_entry()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->directory_entry(), output);
+  }
+
+  // optional bytes raw_data = 2;
+  if (has_raw_data()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->raw_data(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+}
+
+int ClientDownloadRequest_PEImageHeaders_DebugData::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes directory_entry = 1;
+    if (has_directory_entry()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->directory_entry());
+    }
+
+    // optional bytes raw_data = 2;
+    if (has_raw_data()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->raw_data());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest_PEImageHeaders_DebugData*>(&from));
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::MergeFrom(const ClientDownloadRequest_PEImageHeaders_DebugData& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_directory_entry()) {
+      set_directory_entry(from.directory_entry());
+    }
+    if (from.has_raw_data()) {
+      set_raw_data(from.raw_data());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::CopyFrom(const ClientDownloadRequest_PEImageHeaders_DebugData& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_PEImageHeaders_DebugData::IsInitialized() const {
+
+  return true;
+}
+
+void ClientDownloadRequest_PEImageHeaders_DebugData::Swap(ClientDownloadRequest_PEImageHeaders_DebugData* other) {
+  if (other != this) {
+    std::swap(directory_entry_, other->directory_entry_);
+    std::swap(raw_data_, other->raw_data_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest_PEImageHeaders_DebugData::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadRequest_PEImageHeaders::kDosHeaderFieldNumber;
+const int ClientDownloadRequest_PEImageHeaders::kFileHeaderFieldNumber;
+const int ClientDownloadRequest_PEImageHeaders::kOptionalHeaders32FieldNumber;
+const int ClientDownloadRequest_PEImageHeaders::kOptionalHeaders64FieldNumber;
+const int ClientDownloadRequest_PEImageHeaders::kSectionHeaderFieldNumber;
+const int ClientDownloadRequest_PEImageHeaders::kExportSectionDataFieldNumber;
+const int ClientDownloadRequest_PEImageHeaders::kDebugDataFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest_PEImageHeaders::ClientDownloadRequest_PEImageHeaders()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+}
+
+void ClientDownloadRequest_PEImageHeaders::InitAsDefaultInstance() {
+}
+
+ClientDownloadRequest_PEImageHeaders::ClientDownloadRequest_PEImageHeaders(const ClientDownloadRequest_PEImageHeaders& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+}
+
+void ClientDownloadRequest_PEImageHeaders::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  dos_header_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  file_header_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  optional_headers32_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  optional_headers64_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  export_section_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest_PEImageHeaders::~ClientDownloadRequest_PEImageHeaders() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+  SharedDtor();
+}
+
+void ClientDownloadRequest_PEImageHeaders::SharedDtor() {
+  if (dos_header_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete dos_header_;
+  }
+  if (file_header_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete file_header_;
+  }
+  if (optional_headers32_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete optional_headers32_;
+  }
+  if (optional_headers64_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete optional_headers64_;
+  }
+  if (export_section_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete export_section_data_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientDownloadRequest_PEImageHeaders::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest_PEImageHeaders& ClientDownloadRequest_PEImageHeaders::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest_PEImageHeaders* ClientDownloadRequest_PEImageHeaders::default_instance_ = NULL;
+
+ClientDownloadRequest_PEImageHeaders* ClientDownloadRequest_PEImageHeaders::New() const {
+  return new ClientDownloadRequest_PEImageHeaders;
+}
+
+void ClientDownloadRequest_PEImageHeaders::Clear() {
+  if (_has_bits_[0 / 32] & 47) {
+    if (has_dos_header()) {
+      if (dos_header_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        dos_header_->clear();
+      }
+    }
+    if (has_file_header()) {
+      if (file_header_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        file_header_->clear();
+      }
+    }
+    if (has_optional_headers32()) {
+      if (optional_headers32_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        optional_headers32_->clear();
+      }
+    }
+    if (has_optional_headers64()) {
+      if (optional_headers64_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        optional_headers64_->clear();
+      }
+    }
+    if (has_export_section_data()) {
+      if (export_section_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        export_section_data_->clear();
+      }
+    }
+  }
+  section_header_.Clear();
+  debug_data_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest_PEImageHeaders::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes dos_header = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_dos_header()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_file_header;
+        break;
+      }
+
+      // optional bytes file_header = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_file_header:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_file_header()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_optional_headers32;
+        break;
+      }
+
+      // optional bytes optional_headers32 = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_optional_headers32:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_optional_headers32()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_optional_headers64;
+        break;
+      }
+
+      // optional bytes optional_headers64 = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_optional_headers64:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_optional_headers64()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_section_header;
+        break;
+      }
+
+      // repeated bytes section_header = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_section_header:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->add_section_header()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_section_header;
+        if (input->ExpectTag(50)) goto parse_export_section_data;
+        break;
+      }
+
+      // optional bytes export_section_data = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_export_section_data:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_export_section_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_debug_data;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData debug_data = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_debug_data:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_debug_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_debug_data;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest_PEImageHeaders::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+  // optional bytes dos_header = 1;
+  if (has_dos_header()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->dos_header(), output);
+  }
+
+  // optional bytes file_header = 2;
+  if (has_file_header()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->file_header(), output);
+  }
+
+  // optional bytes optional_headers32 = 3;
+  if (has_optional_headers32()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->optional_headers32(), output);
+  }
+
+  // optional bytes optional_headers64 = 4;
+  if (has_optional_headers64()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      4, this->optional_headers64(), output);
+  }
+
+  // repeated bytes section_header = 5;
+  for (int i = 0; i < this->section_header_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytes(
+      5, this->section_header(i), output);
+  }
+
+  // optional bytes export_section_data = 6;
+  if (has_export_section_data()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      6, this->export_section_data(), output);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData debug_data = 7;
+  for (int i = 0; i < this->debug_data_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      7, this->debug_data(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+}
+
+int ClientDownloadRequest_PEImageHeaders::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes dos_header = 1;
+    if (has_dos_header()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->dos_header());
+    }
+
+    // optional bytes file_header = 2;
+    if (has_file_header()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->file_header());
+    }
+
+    // optional bytes optional_headers32 = 3;
+    if (has_optional_headers32()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->optional_headers32());
+    }
+
+    // optional bytes optional_headers64 = 4;
+    if (has_optional_headers64()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->optional_headers64());
+    }
+
+    // optional bytes export_section_data = 6;
+    if (has_export_section_data()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->export_section_data());
+    }
+
+  }
+  // repeated bytes section_header = 5;
+  total_size += 1 * this->section_header_size();
+  for (int i = 0; i < this->section_header_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
+      this->section_header(i));
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData debug_data = 7;
+  total_size += 1 * this->debug_data_size();
+  for (int i = 0; i < this->debug_data_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->debug_data(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest_PEImageHeaders::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest_PEImageHeaders*>(&from));
+}
+
+void ClientDownloadRequest_PEImageHeaders::MergeFrom(const ClientDownloadRequest_PEImageHeaders& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  section_header_.MergeFrom(from.section_header_);
+  debug_data_.MergeFrom(from.debug_data_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_dos_header()) {
+      set_dos_header(from.dos_header());
+    }
+    if (from.has_file_header()) {
+      set_file_header(from.file_header());
+    }
+    if (from.has_optional_headers32()) {
+      set_optional_headers32(from.optional_headers32());
+    }
+    if (from.has_optional_headers64()) {
+      set_optional_headers64(from.optional_headers64());
+    }
+    if (from.has_export_section_data()) {
+      set_export_section_data(from.export_section_data());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest_PEImageHeaders::CopyFrom(const ClientDownloadRequest_PEImageHeaders& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_PEImageHeaders::IsInitialized() const {
+
+  return true;
+}
+
+void ClientDownloadRequest_PEImageHeaders::Swap(ClientDownloadRequest_PEImageHeaders* other) {
+  if (other != this) {
+    std::swap(dos_header_, other->dos_header_);
+    std::swap(file_header_, other->file_header_);
+    std::swap(optional_headers32_, other->optional_headers32_);
+    std::swap(optional_headers64_, other->optional_headers64_);
+    section_header_.Swap(&other->section_header_);
+    std::swap(export_section_data_, other->export_section_data_);
+    debug_data_.Swap(&other->debug_data_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest_PEImageHeaders::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.PEImageHeaders";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadRequest_MachOHeaders_LoadCommand::kCommandIdFieldNumber;
+const int ClientDownloadRequest_MachOHeaders_LoadCommand::kCommandFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest_MachOHeaders_LoadCommand::ClientDownloadRequest_MachOHeaders_LoadCommand()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::InitAsDefaultInstance() {
+}
+
+ClientDownloadRequest_MachOHeaders_LoadCommand::ClientDownloadRequest_MachOHeaders_LoadCommand(const ClientDownloadRequest_MachOHeaders_LoadCommand& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  command_id_ = 0u;
+  command_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest_MachOHeaders_LoadCommand::~ClientDownloadRequest_MachOHeaders_LoadCommand() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+  SharedDtor();
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::SharedDtor() {
+  if (command_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete command_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest_MachOHeaders_LoadCommand& ClientDownloadRequest_MachOHeaders_LoadCommand::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest_MachOHeaders_LoadCommand* ClientDownloadRequest_MachOHeaders_LoadCommand::default_instance_ = NULL;
+
+ClientDownloadRequest_MachOHeaders_LoadCommand* ClientDownloadRequest_MachOHeaders_LoadCommand::New() const {
+  return new ClientDownloadRequest_MachOHeaders_LoadCommand;
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    command_id_ = 0u;
+    if (has_command()) {
+      if (command_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        command_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest_MachOHeaders_LoadCommand::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 command_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &command_id_)));
+          set_has_command_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_command;
+        break;
+      }
+
+      // required bytes command = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_command:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_command()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+  // required uint32 command_id = 1;
+  if (has_command_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->command_id(), output);
+  }
+
+  // required bytes command = 2;
+  if (has_command()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->command(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+}
+
+int ClientDownloadRequest_MachOHeaders_LoadCommand::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 command_id = 1;
+    if (has_command_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->command_id());
+    }
+
+    // required bytes command = 2;
+    if (has_command()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->command());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest_MachOHeaders_LoadCommand*>(&from));
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::MergeFrom(const ClientDownloadRequest_MachOHeaders_LoadCommand& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_command_id()) {
+      set_command_id(from.command_id());
+    }
+    if (from.has_command()) {
+      set_command(from.command());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest_MachOHeaders_LoadCommand::CopyFrom(const ClientDownloadRequest_MachOHeaders_LoadCommand& from) {
+  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::Swap(ClientDownloadRequest_MachOHeaders_LoadCommand* other) {
+  if (other != this) {
+    std::swap(command_id_, other->command_id_);
+    std::swap(command_, other->command_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest_MachOHeaders_LoadCommand::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadRequest_MachOHeaders::kMachHeaderFieldNumber;
+const int ClientDownloadRequest_MachOHeaders::kLoadCommandsFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest_MachOHeaders::ClientDownloadRequest_MachOHeaders()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.MachOHeaders)
+}
+
+void ClientDownloadRequest_MachOHeaders::InitAsDefaultInstance() {
+}
+
+ClientDownloadRequest_MachOHeaders::ClientDownloadRequest_MachOHeaders(const ClientDownloadRequest_MachOHeaders& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.MachOHeaders)
+}
+
+void ClientDownloadRequest_MachOHeaders::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  mach_header_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest_MachOHeaders::~ClientDownloadRequest_MachOHeaders() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.MachOHeaders)
+  SharedDtor();
+}
+
+void ClientDownloadRequest_MachOHeaders::SharedDtor() {
+  if (mach_header_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete mach_header_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientDownloadRequest_MachOHeaders::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest_MachOHeaders& ClientDownloadRequest_MachOHeaders::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest_MachOHeaders* ClientDownloadRequest_MachOHeaders::default_instance_ = NULL;
+
+ClientDownloadRequest_MachOHeaders* ClientDownloadRequest_MachOHeaders::New() const {
+  return new ClientDownloadRequest_MachOHeaders;
+}
+
+void ClientDownloadRequest_MachOHeaders::Clear() {
+  if (has_mach_header()) {
+    if (mach_header_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      mach_header_->clear();
+    }
+  }
+  load_commands_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest_MachOHeaders::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest.MachOHeaders)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required bytes mach_header = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_mach_header()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_load_commands;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand load_commands = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_load_commands:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_load_commands()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_load_commands;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest.MachOHeaders)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest.MachOHeaders)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest_MachOHeaders::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest.MachOHeaders)
+  // required bytes mach_header = 1;
+  if (has_mach_header()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->mach_header(), output);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand load_commands = 2;
+  for (int i = 0; i < this->load_commands_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->load_commands(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest.MachOHeaders)
+}
+
+int ClientDownloadRequest_MachOHeaders::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required bytes mach_header = 1;
+    if (has_mach_header()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->mach_header());
+    }
+
+  }
+  // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand load_commands = 2;
+  total_size += 1 * this->load_commands_size();
+  for (int i = 0; i < this->load_commands_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->load_commands(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest_MachOHeaders::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest_MachOHeaders*>(&from));
+}
+
+void ClientDownloadRequest_MachOHeaders::MergeFrom(const ClientDownloadRequest_MachOHeaders& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  load_commands_.MergeFrom(from.load_commands_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_mach_header()) {
+      set_mach_header(from.mach_header());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest_MachOHeaders::CopyFrom(const ClientDownloadRequest_MachOHeaders& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_MachOHeaders::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->load_commands())) return false;
+  return true;
+}
+
+void ClientDownloadRequest_MachOHeaders::Swap(ClientDownloadRequest_MachOHeaders* other) {
+  if (other != this) {
+    std::swap(mach_header_, other->mach_header_);
+    load_commands_.Swap(&other->load_commands_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest_MachOHeaders::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.MachOHeaders";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadRequest_ImageHeaders::kPeHeadersFieldNumber;
+const int ClientDownloadRequest_ImageHeaders::kMachOHeadersFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest_ImageHeaders::ClientDownloadRequest_ImageHeaders()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.ImageHeaders)
+}
+
+void ClientDownloadRequest_ImageHeaders::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  pe_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_PEImageHeaders*>(
+      ::safe_browsing::ClientDownloadRequest_PEImageHeaders::internal_default_instance());
+#else
+  pe_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_PEImageHeaders*>(&::safe_browsing::ClientDownloadRequest_PEImageHeaders::default_instance());
+#endif
+}
+
+ClientDownloadRequest_ImageHeaders::ClientDownloadRequest_ImageHeaders(const ClientDownloadRequest_ImageHeaders& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.ImageHeaders)
+}
+
+void ClientDownloadRequest_ImageHeaders::SharedCtor() {
+  _cached_size_ = 0;
+  pe_headers_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest_ImageHeaders::~ClientDownloadRequest_ImageHeaders() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.ImageHeaders)
+  SharedDtor();
+}
+
+void ClientDownloadRequest_ImageHeaders::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete pe_headers_;
+  }
+}
+
+void ClientDownloadRequest_ImageHeaders::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest_ImageHeaders& ClientDownloadRequest_ImageHeaders::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest_ImageHeaders* ClientDownloadRequest_ImageHeaders::default_instance_ = NULL;
+
+ClientDownloadRequest_ImageHeaders* ClientDownloadRequest_ImageHeaders::New() const {
+  return new ClientDownloadRequest_ImageHeaders;
+}
+
+void ClientDownloadRequest_ImageHeaders::Clear() {
+  if (has_pe_headers()) {
+    if (pe_headers_ != NULL) pe_headers_->::safe_browsing::ClientDownloadRequest_PEImageHeaders::Clear();
+  }
+  mach_o_headers_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest_ImageHeaders::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest.ImageHeaders)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_pe_headers()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_mach_o_headers;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders mach_o_headers = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_mach_o_headers:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_mach_o_headers()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_mach_o_headers;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest.ImageHeaders)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest.ImageHeaders)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest_ImageHeaders::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest.ImageHeaders)
+  // optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1;
+  if (has_pe_headers()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->pe_headers(), output);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders mach_o_headers = 2;
+  for (int i = 0; i < this->mach_o_headers_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->mach_o_headers(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest.ImageHeaders)
+}
+
+int ClientDownloadRequest_ImageHeaders::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1;
+    if (has_pe_headers()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->pe_headers());
+    }
+
+  }
+  // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders mach_o_headers = 2;
+  total_size += 1 * this->mach_o_headers_size();
+  for (int i = 0; i < this->mach_o_headers_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->mach_o_headers(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest_ImageHeaders::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest_ImageHeaders*>(&from));
+}
+
+void ClientDownloadRequest_ImageHeaders::MergeFrom(const ClientDownloadRequest_ImageHeaders& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  mach_o_headers_.MergeFrom(from.mach_o_headers_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_pe_headers()) {
+      mutable_pe_headers()->::safe_browsing::ClientDownloadRequest_PEImageHeaders::MergeFrom(from.pe_headers());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest_ImageHeaders::CopyFrom(const ClientDownloadRequest_ImageHeaders& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_ImageHeaders::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->mach_o_headers())) return false;
+  return true;
+}
+
+void ClientDownloadRequest_ImageHeaders::Swap(ClientDownloadRequest_ImageHeaders* other) {
+  if (other != this) {
+    std::swap(pe_headers_, other->pe_headers_);
+    mach_o_headers_.Swap(&other->mach_o_headers_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest_ImageHeaders::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.ImageHeaders";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadRequest_ArchivedBinary::kFileBasenameFieldNumber;
+const int ClientDownloadRequest_ArchivedBinary::kDownloadTypeFieldNumber;
+const int ClientDownloadRequest_ArchivedBinary::kDigestsFieldNumber;
+const int ClientDownloadRequest_ArchivedBinary::kLengthFieldNumber;
+const int ClientDownloadRequest_ArchivedBinary::kSignatureFieldNumber;
+const int ClientDownloadRequest_ArchivedBinary::kImageHeadersFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest_ArchivedBinary::ClientDownloadRequest_ArchivedBinary()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+}
+
+void ClientDownloadRequest_ArchivedBinary::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  digests_ = const_cast< ::safe_browsing::ClientDownloadRequest_Digests*>(
+      ::safe_browsing::ClientDownloadRequest_Digests::internal_default_instance());
+#else
+  digests_ = const_cast< ::safe_browsing::ClientDownloadRequest_Digests*>(&::safe_browsing::ClientDownloadRequest_Digests::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>(
+      ::safe_browsing::ClientDownloadRequest_SignatureInfo::internal_default_instance());
+#else
+  signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>(&::safe_browsing::ClientDownloadRequest_SignatureInfo::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(
+      ::safe_browsing::ClientDownloadRequest_ImageHeaders::internal_default_instance());
+#else
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(&::safe_browsing::ClientDownloadRequest_ImageHeaders::default_instance());
+#endif
+}
+
+ClientDownloadRequest_ArchivedBinary::ClientDownloadRequest_ArchivedBinary(const ClientDownloadRequest_ArchivedBinary& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+}
+
+void ClientDownloadRequest_ArchivedBinary::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  file_basename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  download_type_ = 0;
+  digests_ = NULL;
+  length_ = GOOGLE_LONGLONG(0);
+  signature_ = NULL;
+  image_headers_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest_ArchivedBinary::~ClientDownloadRequest_ArchivedBinary() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+  SharedDtor();
+}
+
+void ClientDownloadRequest_ArchivedBinary::SharedDtor() {
+  if (file_basename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete file_basename_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete digests_;
+    delete signature_;
+    delete image_headers_;
+  }
+}
+
+void ClientDownloadRequest_ArchivedBinary::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest_ArchivedBinary& ClientDownloadRequest_ArchivedBinary::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest_ArchivedBinary* ClientDownloadRequest_ArchivedBinary::default_instance_ = NULL;
+
+ClientDownloadRequest_ArchivedBinary* ClientDownloadRequest_ArchivedBinary::New() const {
+  return new ClientDownloadRequest_ArchivedBinary;
+}
+
+void ClientDownloadRequest_ArchivedBinary::Clear() {
+  if (_has_bits_[0 / 32] & 63) {
+    if (has_file_basename()) {
+      if (file_basename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        file_basename_->clear();
+      }
+    }
+    download_type_ = 0;
+    if (has_digests()) {
+      if (digests_ != NULL) digests_->::safe_browsing::ClientDownloadRequest_Digests::Clear();
+    }
+    length_ = GOOGLE_LONGLONG(0);
+    if (has_signature()) {
+      if (signature_ != NULL) signature_->::safe_browsing::ClientDownloadRequest_SignatureInfo::Clear();
+    }
+    if (has_image_headers()) {
+      if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest_ArchivedBinary::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string file_basename = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_file_basename()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_download_type;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_download_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientDownloadRequest_DownloadType_IsValid(value)) {
+            set_download_type(static_cast< ::safe_browsing::ClientDownloadRequest_DownloadType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_digests;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.Digests digests = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_digests:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_digests()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_length;
+        break;
+      }
+
+      // optional int64 length = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_length:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &length_)));
+          set_has_length();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_signature;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_signature:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_signature()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_image_headers;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_image_headers:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_image_headers()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest_ArchivedBinary::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+  // optional string file_basename = 1;
+  if (has_file_basename()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->file_basename(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 2;
+  if (has_download_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->download_type(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.Digests digests = 3;
+  if (has_digests()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->digests(), output);
+  }
+
+  // optional int64 length = 4;
+  if (has_length()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(4, this->length(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+  if (has_signature()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      5, this->signature(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+  if (has_image_headers()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      6, this->image_headers(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+}
+
+int ClientDownloadRequest_ArchivedBinary::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string file_basename = 1;
+    if (has_file_basename()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->file_basename());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 2;
+    if (has_download_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->download_type());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.Digests digests = 3;
+    if (has_digests()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->digests());
+    }
+
+    // optional int64 length = 4;
+    if (has_length()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->length());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+    if (has_signature()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->signature());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+    if (has_image_headers()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->image_headers());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest_ArchivedBinary::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest_ArchivedBinary*>(&from));
+}
+
+void ClientDownloadRequest_ArchivedBinary::MergeFrom(const ClientDownloadRequest_ArchivedBinary& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_file_basename()) {
+      set_file_basename(from.file_basename());
+    }
+    if (from.has_download_type()) {
+      set_download_type(from.download_type());
+    }
+    if (from.has_digests()) {
+      mutable_digests()->::safe_browsing::ClientDownloadRequest_Digests::MergeFrom(from.digests());
+    }
+    if (from.has_length()) {
+      set_length(from.length());
+    }
+    if (from.has_signature()) {
+      mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(from.signature());
+    }
+    if (from.has_image_headers()) {
+      mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(from.image_headers());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest_ArchivedBinary::CopyFrom(const ClientDownloadRequest_ArchivedBinary& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_ArchivedBinary::IsInitialized() const {
+
+  if (has_signature()) {
+    if (!this->signature().IsInitialized()) return false;
+  }
+  if (has_image_headers()) {
+    if (!this->image_headers().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientDownloadRequest_ArchivedBinary::Swap(ClientDownloadRequest_ArchivedBinary* other) {
+  if (other != this) {
+    std::swap(file_basename_, other->file_basename_);
+    std::swap(download_type_, other->download_type_);
+    std::swap(digests_, other->digests_);
+    std::swap(length_, other->length_);
+    std::swap(signature_, other->signature_);
+    std::swap(image_headers_, other->image_headers_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest_ArchivedBinary::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.ArchivedBinary";
+}
+
+
+// -------------------------------------------------------------------
+
+bool ClientDownloadRequest_URLChainEntry_URLType_IsValid(int value) {
+  switch(value) {
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const ClientDownloadRequest_URLChainEntry_URLType ClientDownloadRequest_URLChainEntry::DOWNLOAD_URL;
+const ClientDownloadRequest_URLChainEntry_URLType ClientDownloadRequest_URLChainEntry::DOWNLOAD_REFERRER;
+const ClientDownloadRequest_URLChainEntry_URLType ClientDownloadRequest_URLChainEntry::LANDING_PAGE;
+const ClientDownloadRequest_URLChainEntry_URLType ClientDownloadRequest_URLChainEntry::LANDING_REFERRER;
+const ClientDownloadRequest_URLChainEntry_URLType ClientDownloadRequest_URLChainEntry::CLIENT_REDIRECT;
+const ClientDownloadRequest_URLChainEntry_URLType ClientDownloadRequest_URLChainEntry::SERVER_REDIRECT;
+const ClientDownloadRequest_URLChainEntry_URLType ClientDownloadRequest_URLChainEntry::URLType_MIN;
+const ClientDownloadRequest_URLChainEntry_URLType ClientDownloadRequest_URLChainEntry::URLType_MAX;
+const int ClientDownloadRequest_URLChainEntry::URLType_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ClientDownloadRequest_URLChainEntry::kUrlFieldNumber;
+const int ClientDownloadRequest_URLChainEntry::kTypeFieldNumber;
+const int ClientDownloadRequest_URLChainEntry::kIpAddressFieldNumber;
+const int ClientDownloadRequest_URLChainEntry::kReferrerFieldNumber;
+const int ClientDownloadRequest_URLChainEntry::kMainFrameReferrerFieldNumber;
+const int ClientDownloadRequest_URLChainEntry::kIsRetargetingFieldNumber;
+const int ClientDownloadRequest_URLChainEntry::kIsUserInitiatedFieldNumber;
+const int ClientDownloadRequest_URLChainEntry::kTimestampInMillisecFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest_URLChainEntry::ClientDownloadRequest_URLChainEntry()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest.URLChainEntry)
+}
+
+void ClientDownloadRequest_URLChainEntry::InitAsDefaultInstance() {
+}
+
+ClientDownloadRequest_URLChainEntry::ClientDownloadRequest_URLChainEntry(const ClientDownloadRequest_URLChainEntry& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest.URLChainEntry)
+}
+
+void ClientDownloadRequest_URLChainEntry::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  type_ = 1;
+  ip_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  main_frame_referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  is_retargeting_ = false;
+  is_user_initiated_ = false;
+  timestamp_in_millisec_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest_URLChainEntry::~ClientDownloadRequest_URLChainEntry() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest.URLChainEntry)
+  SharedDtor();
+}
+
+void ClientDownloadRequest_URLChainEntry::SharedDtor() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (ip_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete ip_address_;
+  }
+  if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete referrer_;
+  }
+  if (main_frame_referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete main_frame_referrer_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientDownloadRequest_URLChainEntry::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest_URLChainEntry& ClientDownloadRequest_URLChainEntry::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest_URLChainEntry* ClientDownloadRequest_URLChainEntry::default_instance_ = NULL;
+
+ClientDownloadRequest_URLChainEntry* ClientDownloadRequest_URLChainEntry::New() const {
+  return new ClientDownloadRequest_URLChainEntry;
+}
+
+void ClientDownloadRequest_URLChainEntry::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClientDownloadRequest_URLChainEntry*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(is_retargeting_, timestamp_in_millisec_);
+    if (has_url()) {
+      if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_->clear();
+      }
+    }
+    type_ = 1;
+    if (has_ip_address()) {
+      if (ip_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        ip_address_->clear();
+      }
+    }
+    if (has_referrer()) {
+      if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        referrer_->clear();
+      }
+    }
+    if (has_main_frame_referrer()) {
+      if (main_frame_referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        main_frame_referrer_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest_URLChainEntry::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest.URLChainEntry)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string url = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_type;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.URLChainEntry.URLType type = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientDownloadRequest_URLChainEntry_URLType_IsValid(value)) {
+            set_type(static_cast< ::safe_browsing::ClientDownloadRequest_URLChainEntry_URLType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_ip_address;
+        break;
+      }
+
+      // optional string ip_address = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_ip_address:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_ip_address()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_referrer;
+        break;
+      }
+
+      // optional string referrer = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_referrer:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_referrer()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_main_frame_referrer;
+        break;
+      }
+
+      // optional string main_frame_referrer = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_main_frame_referrer:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_main_frame_referrer()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_is_retargeting;
+        break;
+      }
+
+      // optional bool is_retargeting = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_is_retargeting:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_retargeting_)));
+          set_has_is_retargeting();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_is_user_initiated;
+        break;
+      }
+
+      // optional bool is_user_initiated = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_is_user_initiated:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_user_initiated_)));
+          set_has_is_user_initiated();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(65)) goto parse_timestamp_in_millisec;
+        break;
+      }
+
+      // optional double timestamp_in_millisec = 8;
+      case 8: {
+        if (tag == 65) {
+         parse_timestamp_in_millisec:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &timestamp_in_millisec_)));
+          set_has_timestamp_in_millisec();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest.URLChainEntry)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest.URLChainEntry)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest_URLChainEntry::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest.URLChainEntry)
+  // optional string url = 1;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->url(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.URLChainEntry.URLType type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->type(), output);
+  }
+
+  // optional string ip_address = 3;
+  if (has_ip_address()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->ip_address(), output);
+  }
+
+  // optional string referrer = 4;
+  if (has_referrer()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->referrer(), output);
+  }
+
+  // optional string main_frame_referrer = 5;
+  if (has_main_frame_referrer()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->main_frame_referrer(), output);
+  }
+
+  // optional bool is_retargeting = 6;
+  if (has_is_retargeting()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->is_retargeting(), output);
+  }
+
+  // optional bool is_user_initiated = 7;
+  if (has_is_user_initiated()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->is_user_initiated(), output);
+  }
+
+  // optional double timestamp_in_millisec = 8;
+  if (has_timestamp_in_millisec()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(8, this->timestamp_in_millisec(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest.URLChainEntry)
+}
+
+int ClientDownloadRequest_URLChainEntry::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string url = 1;
+    if (has_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->url());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.URLChainEntry.URLType type = 2;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
+    }
+
+    // optional string ip_address = 3;
+    if (has_ip_address()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->ip_address());
+    }
+
+    // optional string referrer = 4;
+    if (has_referrer()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->referrer());
+    }
+
+    // optional string main_frame_referrer = 5;
+    if (has_main_frame_referrer()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->main_frame_referrer());
+    }
+
+    // optional bool is_retargeting = 6;
+    if (has_is_retargeting()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool is_user_initiated = 7;
+    if (has_is_user_initiated()) {
+      total_size += 1 + 1;
+    }
+
+    // optional double timestamp_in_millisec = 8;
+    if (has_timestamp_in_millisec()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest_URLChainEntry::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest_URLChainEntry*>(&from));
+}
+
+void ClientDownloadRequest_URLChainEntry::MergeFrom(const ClientDownloadRequest_URLChainEntry& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_url()) {
+      set_url(from.url());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_ip_address()) {
+      set_ip_address(from.ip_address());
+    }
+    if (from.has_referrer()) {
+      set_referrer(from.referrer());
+    }
+    if (from.has_main_frame_referrer()) {
+      set_main_frame_referrer(from.main_frame_referrer());
+    }
+    if (from.has_is_retargeting()) {
+      set_is_retargeting(from.is_retargeting());
+    }
+    if (from.has_is_user_initiated()) {
+      set_is_user_initiated(from.is_user_initiated());
+    }
+    if (from.has_timestamp_in_millisec()) {
+      set_timestamp_in_millisec(from.timestamp_in_millisec());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest_URLChainEntry::CopyFrom(const ClientDownloadRequest_URLChainEntry& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest_URLChainEntry::IsInitialized() const {
+
+  return true;
+}
+
+void ClientDownloadRequest_URLChainEntry::Swap(ClientDownloadRequest_URLChainEntry* other) {
+  if (other != this) {
+    std::swap(url_, other->url_);
+    std::swap(type_, other->type_);
+    std::swap(ip_address_, other->ip_address_);
+    std::swap(referrer_, other->referrer_);
+    std::swap(main_frame_referrer_, other->main_frame_referrer_);
+    std::swap(is_retargeting_, other->is_retargeting_);
+    std::swap(is_user_initiated_, other->is_user_initiated_);
+    std::swap(timestamp_in_millisec_, other->timestamp_in_millisec_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest_URLChainEntry::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest.URLChainEntry";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadRequest::kUrlFieldNumber;
+const int ClientDownloadRequest::kDigestsFieldNumber;
+const int ClientDownloadRequest::kLengthFieldNumber;
+const int ClientDownloadRequest::kResourcesFieldNumber;
+const int ClientDownloadRequest::kSignatureFieldNumber;
+const int ClientDownloadRequest::kUserInitiatedFieldNumber;
+const int ClientDownloadRequest::kFileBasenameFieldNumber;
+const int ClientDownloadRequest::kDownloadTypeFieldNumber;
+const int ClientDownloadRequest::kLocaleFieldNumber;
+const int ClientDownloadRequest::kImageHeadersFieldNumber;
+const int ClientDownloadRequest::kArchivedBinaryFieldNumber;
+const int ClientDownloadRequest::kPopulationFieldNumber;
+const int ClientDownloadRequest::kArchiveValidFieldNumber;
+const int ClientDownloadRequest::kSkippedUrlWhitelistFieldNumber;
+const int ClientDownloadRequest::kSkippedCertificateWhitelistFieldNumber;
+const int ClientDownloadRequest::kAlternateExtensionsFieldNumber;
+const int ClientDownloadRequest::kUrlChainFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadRequest::ClientDownloadRequest()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadRequest)
+}
+
+void ClientDownloadRequest::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  digests_ = const_cast< ::safe_browsing::ClientDownloadRequest_Digests*>(
+      ::safe_browsing::ClientDownloadRequest_Digests::internal_default_instance());
+#else
+  digests_ = const_cast< ::safe_browsing::ClientDownloadRequest_Digests*>(&::safe_browsing::ClientDownloadRequest_Digests::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>(
+      ::safe_browsing::ClientDownloadRequest_SignatureInfo::internal_default_instance());
+#else
+  signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>(&::safe_browsing::ClientDownloadRequest_SignatureInfo::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(
+      ::safe_browsing::ClientDownloadRequest_ImageHeaders::internal_default_instance());
+#else
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(&::safe_browsing::ClientDownloadRequest_ImageHeaders::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  population_ = const_cast< ::safe_browsing::ChromeUserPopulation*>(
+      ::safe_browsing::ChromeUserPopulation::internal_default_instance());
+#else
+  population_ = const_cast< ::safe_browsing::ChromeUserPopulation*>(&::safe_browsing::ChromeUserPopulation::default_instance());
+#endif
+}
+
+ClientDownloadRequest::ClientDownloadRequest(const ClientDownloadRequest& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadRequest)
+}
+
+void ClientDownloadRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  digests_ = NULL;
+  length_ = GOOGLE_LONGLONG(0);
+  signature_ = NULL;
+  user_initiated_ = false;
+  file_basename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  download_type_ = 0;
+  locale_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  image_headers_ = NULL;
+  population_ = NULL;
+  archive_valid_ = false;
+  skipped_url_whitelist_ = false;
+  skipped_certificate_whitelist_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadRequest::~ClientDownloadRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadRequest)
+  SharedDtor();
+}
+
+void ClientDownloadRequest::SharedDtor() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (file_basename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete file_basename_;
+  }
+  if (locale_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete locale_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete digests_;
+    delete signature_;
+    delete image_headers_;
+    delete population_;
+  }
+}
+
+void ClientDownloadRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadRequest& ClientDownloadRequest::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadRequest* ClientDownloadRequest::default_instance_ = NULL;
+
+ClientDownloadRequest* ClientDownloadRequest::New() const {
+  return new ClientDownloadRequest;
+}
+
+void ClientDownloadRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClientDownloadRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 247) {
+    ZR_(download_type_, user_initiated_);
+    if (has_url()) {
+      if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_->clear();
+      }
+    }
+    if (has_digests()) {
+      if (digests_ != NULL) digests_->::safe_browsing::ClientDownloadRequest_Digests::Clear();
+    }
+    length_ = GOOGLE_LONGLONG(0);
+    if (has_signature()) {
+      if (signature_ != NULL) signature_->::safe_browsing::ClientDownloadRequest_SignatureInfo::Clear();
+    }
+    if (has_file_basename()) {
+      if (file_basename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        file_basename_->clear();
+      }
+    }
+  }
+  if (_has_bits_[8 / 32] & 31488) {
+    ZR_(archive_valid_, skipped_certificate_whitelist_);
+    if (has_locale()) {
+      if (locale_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        locale_->clear();
+      }
+    }
+    if (has_image_headers()) {
+      if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+    }
+    if (has_population()) {
+      if (population_ != NULL) population_->::safe_browsing::ChromeUserPopulation::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  resources_.Clear();
+  archived_binary_.Clear();
+  alternate_extensions_.Clear();
+  url_chain_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string url = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_digests;
+        break;
+      }
+
+      // required .safe_browsing.ClientDownloadRequest.Digests digests = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_digests:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_digests()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_length;
+        break;
+      }
+
+      // required int64 length = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_length:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &length_)));
+          set_has_length();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_resources;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_resources:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_resources()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_resources;
+        if (input->ExpectTag(42)) goto parse_signature;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_signature:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_signature()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_user_initiated;
+        break;
+      }
+
+      // optional bool user_initiated = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_user_initiated:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &user_initiated_)));
+          set_has_user_initiated();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_file_basename;
+        break;
+      }
+
+      // optional string file_basename = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_file_basename:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_file_basename()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(80)) goto parse_download_type;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 10 [default = WIN_EXECUTABLE];
+      case 10: {
+        if (tag == 80) {
+         parse_download_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientDownloadRequest_DownloadType_IsValid(value)) {
+            set_download_type(static_cast< ::safe_browsing::ClientDownloadRequest_DownloadType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(90)) goto parse_locale;
+        break;
+      }
+
+      // optional string locale = 11;
+      case 11: {
+        if (tag == 90) {
+         parse_locale:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_locale()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(146)) goto parse_image_headers;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 18;
+      case 18: {
+        if (tag == 146) {
+         parse_image_headers:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_image_headers()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(178)) goto parse_archived_binary;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientDownloadRequest.ArchivedBinary archived_binary = 22;
+      case 22: {
+        if (tag == 178) {
+         parse_archived_binary:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_archived_binary()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(178)) goto parse_archived_binary;
+        if (input->ExpectTag(194)) goto parse_population;
+        break;
+      }
+
+      // optional .safe_browsing.ChromeUserPopulation population = 24;
+      case 24: {
+        if (tag == 194) {
+         parse_population:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_population()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(208)) goto parse_archive_valid;
+        break;
+      }
+
+      // optional bool archive_valid = 26;
+      case 26: {
+        if (tag == 208) {
+         parse_archive_valid:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &archive_valid_)));
+          set_has_archive_valid();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(224)) goto parse_skipped_url_whitelist;
+        break;
+      }
+
+      // optional bool skipped_url_whitelist = 28;
+      case 28: {
+        if (tag == 224) {
+         parse_skipped_url_whitelist:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &skipped_url_whitelist_)));
+          set_has_skipped_url_whitelist();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(248)) goto parse_skipped_certificate_whitelist;
+        break;
+      }
+
+      // optional bool skipped_certificate_whitelist = 31;
+      case 31: {
+        if (tag == 248) {
+         parse_skipped_certificate_whitelist:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &skipped_certificate_whitelist_)));
+          set_has_skipped_certificate_whitelist();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(282)) goto parse_alternate_extensions;
+        break;
+      }
+
+      // repeated string alternate_extensions = 35;
+      case 35: {
+        if (tag == 282) {
+         parse_alternate_extensions:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_alternate_extensions()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(282)) goto parse_alternate_extensions;
+        if (input->ExpectTag(290)) goto parse_url_chain;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientDownloadRequest.URLChainEntry url_chain = 36;
+      case 36: {
+        if (tag == 290) {
+         parse_url_chain:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_url_chain()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(290)) goto parse_url_chain;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadRequest)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadRequest)
+  // required string url = 1;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->url(), output);
+  }
+
+  // required .safe_browsing.ClientDownloadRequest.Digests digests = 2;
+  if (has_digests()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->digests(), output);
+  }
+
+  // required int64 length = 3;
+  if (has_length()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->length(), output);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4;
+  for (int i = 0; i < this->resources_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->resources(i), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+  if (has_signature()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      5, this->signature(), output);
+  }
+
+  // optional bool user_initiated = 6;
+  if (has_user_initiated()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->user_initiated(), output);
+  }
+
+  // optional string file_basename = 9;
+  if (has_file_basename()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      9, this->file_basename(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 10 [default = WIN_EXECUTABLE];
+  if (has_download_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      10, this->download_type(), output);
+  }
+
+  // optional string locale = 11;
+  if (has_locale()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      11, this->locale(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 18;
+  if (has_image_headers()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      18, this->image_headers(), output);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.ArchivedBinary archived_binary = 22;
+  for (int i = 0; i < this->archived_binary_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      22, this->archived_binary(i), output);
+  }
+
+  // optional .safe_browsing.ChromeUserPopulation population = 24;
+  if (has_population()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      24, this->population(), output);
+  }
+
+  // optional bool archive_valid = 26;
+  if (has_archive_valid()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(26, this->archive_valid(), output);
+  }
+
+  // optional bool skipped_url_whitelist = 28;
+  if (has_skipped_url_whitelist()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(28, this->skipped_url_whitelist(), output);
+  }
+
+  // optional bool skipped_certificate_whitelist = 31;
+  if (has_skipped_certificate_whitelist()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(31, this->skipped_certificate_whitelist(), output);
+  }
+
+  // repeated string alternate_extensions = 35;
+  for (int i = 0; i < this->alternate_extensions_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      35, this->alternate_extensions(i), output);
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.URLChainEntry url_chain = 36;
+  for (int i = 0; i < this->url_chain_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      36, this->url_chain(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadRequest)
+}
+
+int ClientDownloadRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string url = 1;
+    if (has_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->url());
+    }
+
+    // required .safe_browsing.ClientDownloadRequest.Digests digests = 2;
+    if (has_digests()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->digests());
+    }
+
+    // required int64 length = 3;
+    if (has_length()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->length());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+    if (has_signature()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->signature());
+    }
+
+    // optional bool user_initiated = 6;
+    if (has_user_initiated()) {
+      total_size += 1 + 1;
+    }
+
+    // optional string file_basename = 9;
+    if (has_file_basename()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->file_basename());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 10 [default = WIN_EXECUTABLE];
+    if (has_download_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->download_type());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional string locale = 11;
+    if (has_locale()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->locale());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 18;
+    if (has_image_headers()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->image_headers());
+    }
+
+    // optional .safe_browsing.ChromeUserPopulation population = 24;
+    if (has_population()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->population());
+    }
+
+    // optional bool archive_valid = 26;
+    if (has_archive_valid()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool skipped_url_whitelist = 28;
+    if (has_skipped_url_whitelist()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool skipped_certificate_whitelist = 31;
+    if (has_skipped_certificate_whitelist()) {
+      total_size += 2 + 1;
+    }
+
+  }
+  // repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4;
+  total_size += 1 * this->resources_size();
+  for (int i = 0; i < this->resources_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->resources(i));
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.ArchivedBinary archived_binary = 22;
+  total_size += 2 * this->archived_binary_size();
+  for (int i = 0; i < this->archived_binary_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->archived_binary(i));
+  }
+
+  // repeated string alternate_extensions = 35;
+  total_size += 2 * this->alternate_extensions_size();
+  for (int i = 0; i < this->alternate_extensions_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->alternate_extensions(i));
+  }
+
+  // repeated .safe_browsing.ClientDownloadRequest.URLChainEntry url_chain = 36;
+  total_size += 2 * this->url_chain_size();
+  for (int i = 0; i < this->url_chain_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->url_chain(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadRequest::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadRequest*>(&from));
+}
+
+void ClientDownloadRequest::MergeFrom(const ClientDownloadRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  resources_.MergeFrom(from.resources_);
+  archived_binary_.MergeFrom(from.archived_binary_);
+  alternate_extensions_.MergeFrom(from.alternate_extensions_);
+  url_chain_.MergeFrom(from.url_chain_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_url()) {
+      set_url(from.url());
+    }
+    if (from.has_digests()) {
+      mutable_digests()->::safe_browsing::ClientDownloadRequest_Digests::MergeFrom(from.digests());
+    }
+    if (from.has_length()) {
+      set_length(from.length());
+    }
+    if (from.has_signature()) {
+      mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(from.signature());
+    }
+    if (from.has_user_initiated()) {
+      set_user_initiated(from.user_initiated());
+    }
+    if (from.has_file_basename()) {
+      set_file_basename(from.file_basename());
+    }
+    if (from.has_download_type()) {
+      set_download_type(from.download_type());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_locale()) {
+      set_locale(from.locale());
+    }
+    if (from.has_image_headers()) {
+      mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(from.image_headers());
+    }
+    if (from.has_population()) {
+      mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(from.population());
+    }
+    if (from.has_archive_valid()) {
+      set_archive_valid(from.archive_valid());
+    }
+    if (from.has_skipped_url_whitelist()) {
+      set_skipped_url_whitelist(from.skipped_url_whitelist());
+    }
+    if (from.has_skipped_certificate_whitelist()) {
+      set_skipped_certificate_whitelist(from.skipped_certificate_whitelist());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadRequest::CopyFrom(const ClientDownloadRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->resources())) return false;
+  if (has_signature()) {
+    if (!this->signature().IsInitialized()) return false;
+  }
+  if (has_image_headers()) {
+    if (!this->image_headers().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->archived_binary())) return false;
+  return true;
+}
+
+void ClientDownloadRequest::Swap(ClientDownloadRequest* other) {
+  if (other != this) {
+    std::swap(url_, other->url_);
+    std::swap(digests_, other->digests_);
+    std::swap(length_, other->length_);
+    resources_.Swap(&other->resources_);
+    std::swap(signature_, other->signature_);
+    std::swap(user_initiated_, other->user_initiated_);
+    std::swap(file_basename_, other->file_basename_);
+    std::swap(download_type_, other->download_type_);
+    std::swap(locale_, other->locale_);
+    std::swap(image_headers_, other->image_headers_);
+    archived_binary_.Swap(&other->archived_binary_);
+    std::swap(population_, other->population_);
+    std::swap(archive_valid_, other->archive_valid_);
+    std::swap(skipped_url_whitelist_, other->skipped_url_whitelist_);
+    std::swap(skipped_certificate_whitelist_, other->skipped_certificate_whitelist_);
+    alternate_extensions_.Swap(&other->alternate_extensions_);
+    url_chain_.Swap(&other->url_chain_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadRequest::GetTypeName() const {
+  return "safe_browsing.ClientDownloadRequest";
+}
+
+
+// ===================================================================
+
+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;
+  }
+}
+
+#ifndef _MSC_VER
+const ClientDownloadResponse_Verdict ClientDownloadResponse::SAFE;
+const ClientDownloadResponse_Verdict ClientDownloadResponse::DANGEROUS;
+const ClientDownloadResponse_Verdict ClientDownloadResponse::UNCOMMON;
+const ClientDownloadResponse_Verdict ClientDownloadResponse::POTENTIALLY_UNWANTED;
+const ClientDownloadResponse_Verdict ClientDownloadResponse::DANGEROUS_HOST;
+const ClientDownloadResponse_Verdict ClientDownloadResponse::UNKNOWN;
+const ClientDownloadResponse_Verdict ClientDownloadResponse::Verdict_MIN;
+const ClientDownloadResponse_Verdict ClientDownloadResponse::Verdict_MAX;
+const int ClientDownloadResponse::Verdict_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ClientDownloadResponse_MoreInfo::kDescriptionFieldNumber;
+const int ClientDownloadResponse_MoreInfo::kUrlFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadResponse_MoreInfo::ClientDownloadResponse_MoreInfo()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadResponse.MoreInfo)
+}
+
+void ClientDownloadResponse_MoreInfo::InitAsDefaultInstance() {
+}
+
+ClientDownloadResponse_MoreInfo::ClientDownloadResponse_MoreInfo(const ClientDownloadResponse_MoreInfo& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadResponse.MoreInfo)
+}
+
+void ClientDownloadResponse_MoreInfo::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadResponse_MoreInfo::~ClientDownloadResponse_MoreInfo() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadResponse.MoreInfo)
+  SharedDtor();
+}
+
+void ClientDownloadResponse_MoreInfo::SharedDtor() {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientDownloadResponse_MoreInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadResponse_MoreInfo& ClientDownloadResponse_MoreInfo::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadResponse_MoreInfo* ClientDownloadResponse_MoreInfo::default_instance_ = NULL;
+
+ClientDownloadResponse_MoreInfo* ClientDownloadResponse_MoreInfo::New() const {
+  return new ClientDownloadResponse_MoreInfo;
+}
+
+void ClientDownloadResponse_MoreInfo::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_description()) {
+      if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        description_->clear();
+      }
+    }
+    if (has_url()) {
+      if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadResponse_MoreInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadResponse.MoreInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string description = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_description()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_url;
+        break;
+      }
+
+      // optional string url = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_url:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadResponse.MoreInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadResponse.MoreInfo)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadResponse_MoreInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadResponse.MoreInfo)
+  // optional string description = 1;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->description(), output);
+  }
+
+  // optional string url = 2;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->url(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadResponse.MoreInfo)
+}
+
+int ClientDownloadResponse_MoreInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string description = 1;
+    if (has_description()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->description());
+    }
+
+    // optional string url = 2;
+    if (has_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->url());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadResponse_MoreInfo::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadResponse_MoreInfo*>(&from));
+}
+
+void ClientDownloadResponse_MoreInfo::MergeFrom(const ClientDownloadResponse_MoreInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_description()) {
+      set_description(from.description());
+    }
+    if (from.has_url()) {
+      set_url(from.url());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadResponse_MoreInfo::CopyFrom(const ClientDownloadResponse_MoreInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadResponse_MoreInfo::IsInitialized() const {
+
+  return true;
+}
+
+void ClientDownloadResponse_MoreInfo::Swap(ClientDownloadResponse_MoreInfo* other) {
+  if (other != this) {
+    std::swap(description_, other->description_);
+    std::swap(url_, other->url_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadResponse_MoreInfo::GetTypeName() const {
+  return "safe_browsing.ClientDownloadResponse.MoreInfo";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadResponse::kVerdictFieldNumber;
+const int ClientDownloadResponse::kMoreInfoFieldNumber;
+const int ClientDownloadResponse::kTokenFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadResponse::ClientDownloadResponse()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadResponse)
+}
+
+void ClientDownloadResponse::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  more_info_ = const_cast< ::safe_browsing::ClientDownloadResponse_MoreInfo*>(
+      ::safe_browsing::ClientDownloadResponse_MoreInfo::internal_default_instance());
+#else
+  more_info_ = const_cast< ::safe_browsing::ClientDownloadResponse_MoreInfo*>(&::safe_browsing::ClientDownloadResponse_MoreInfo::default_instance());
+#endif
+}
+
+ClientDownloadResponse::ClientDownloadResponse(const ClientDownloadResponse& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadResponse)
+}
+
+void ClientDownloadResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  verdict_ = 0;
+  more_info_ = NULL;
+  token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadResponse::~ClientDownloadResponse() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadResponse)
+  SharedDtor();
+}
+
+void ClientDownloadResponse::SharedDtor() {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete token_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete more_info_;
+  }
+}
+
+void ClientDownloadResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadResponse& ClientDownloadResponse::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadResponse* ClientDownloadResponse::default_instance_ = NULL;
+
+ClientDownloadResponse* ClientDownloadResponse::New() const {
+  return new ClientDownloadResponse;
+}
+
+void ClientDownloadResponse::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    verdict_ = 0;
+    if (has_more_info()) {
+      if (more_info_ != NULL) more_info_->::safe_browsing::ClientDownloadResponse_MoreInfo::Clear();
+    }
+    if (has_token()) {
+      if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        token_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .safe_browsing.ClientDownloadResponse.Verdict verdict = 1 [default = SAFE];
+      case 1: {
+        if (tag == 8) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientDownloadResponse_Verdict_IsValid(value)) {
+            set_verdict(static_cast< ::safe_browsing::ClientDownloadResponse_Verdict >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_more_info;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadResponse.MoreInfo more_info = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_more_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_more_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_token;
+        break;
+      }
+
+      // optional bytes token = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_token:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_token()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadResponse)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadResponse)
+  // optional .safe_browsing.ClientDownloadResponse.Verdict verdict = 1 [default = SAFE];
+  if (has_verdict()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->verdict(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadResponse.MoreInfo more_info = 2;
+  if (has_more_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->more_info(), output);
+  }
+
+  // optional bytes token = 3;
+  if (has_token()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->token(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadResponse)
+}
+
+int ClientDownloadResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .safe_browsing.ClientDownloadResponse.Verdict verdict = 1 [default = SAFE];
+    if (has_verdict()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->verdict());
+    }
+
+    // optional .safe_browsing.ClientDownloadResponse.MoreInfo more_info = 2;
+    if (has_more_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->more_info());
+    }
+
+    // optional bytes token = 3;
+    if (has_token()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->token());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadResponse::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadResponse*>(&from));
+}
+
+void ClientDownloadResponse::MergeFrom(const ClientDownloadResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_verdict()) {
+      set_verdict(from.verdict());
+    }
+    if (from.has_more_info()) {
+      mutable_more_info()->::safe_browsing::ClientDownloadResponse_MoreInfo::MergeFrom(from.more_info());
+    }
+    if (from.has_token()) {
+      set_token(from.token());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadResponse::CopyFrom(const ClientDownloadResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadResponse::IsInitialized() const {
+
+  return true;
+}
+
+void ClientDownloadResponse::Swap(ClientDownloadResponse* other) {
+  if (other != this) {
+    std::swap(verdict_, other->verdict_);
+    std::swap(more_info_, other->more_info_);
+    std::swap(token_, other->token_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadResponse::GetTypeName() const {
+  return "safe_browsing.ClientDownloadResponse";
+}
+
+
+// ===================================================================
+
+bool ClientDownloadReport_Reason_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const ClientDownloadReport_Reason ClientDownloadReport::SHARE;
+const ClientDownloadReport_Reason ClientDownloadReport::FALSE_POSITIVE;
+const ClientDownloadReport_Reason ClientDownloadReport::APPEAL;
+const ClientDownloadReport_Reason ClientDownloadReport::Reason_MIN;
+const ClientDownloadReport_Reason ClientDownloadReport::Reason_MAX;
+const int ClientDownloadReport::Reason_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ClientDownloadReport_UserInformation::kEmailFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadReport_UserInformation::ClientDownloadReport_UserInformation()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadReport.UserInformation)
+}
+
+void ClientDownloadReport_UserInformation::InitAsDefaultInstance() {
+}
+
+ClientDownloadReport_UserInformation::ClientDownloadReport_UserInformation(const ClientDownloadReport_UserInformation& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadReport.UserInformation)
+}
+
+void ClientDownloadReport_UserInformation::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadReport_UserInformation::~ClientDownloadReport_UserInformation() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadReport.UserInformation)
+  SharedDtor();
+}
+
+void ClientDownloadReport_UserInformation::SharedDtor() {
+  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete email_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientDownloadReport_UserInformation::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadReport_UserInformation& ClientDownloadReport_UserInformation::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadReport_UserInformation* ClientDownloadReport_UserInformation::default_instance_ = NULL;
+
+ClientDownloadReport_UserInformation* ClientDownloadReport_UserInformation::New() const {
+  return new ClientDownloadReport_UserInformation;
+}
+
+void ClientDownloadReport_UserInformation::Clear() {
+  if (has_email()) {
+    if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      email_->clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadReport_UserInformation::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadReport.UserInformation)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string email = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_email()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadReport.UserInformation)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadReport.UserInformation)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadReport_UserInformation::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadReport.UserInformation)
+  // optional string email = 1;
+  if (has_email()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->email(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadReport.UserInformation)
+}
+
+int ClientDownloadReport_UserInformation::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string email = 1;
+    if (has_email()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->email());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadReport_UserInformation::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadReport_UserInformation*>(&from));
+}
+
+void ClientDownloadReport_UserInformation::MergeFrom(const ClientDownloadReport_UserInformation& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_email()) {
+      set_email(from.email());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadReport_UserInformation::CopyFrom(const ClientDownloadReport_UserInformation& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadReport_UserInformation::IsInitialized() const {
+
+  return true;
+}
+
+void ClientDownloadReport_UserInformation::Swap(ClientDownloadReport_UserInformation* other) {
+  if (other != this) {
+    std::swap(email_, other->email_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadReport_UserInformation::GetTypeName() const {
+  return "safe_browsing.ClientDownloadReport.UserInformation";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientDownloadReport::kReasonFieldNumber;
+const int ClientDownloadReport::kDownloadRequestFieldNumber;
+const int ClientDownloadReport::kUserInformationFieldNumber;
+const int ClientDownloadReport::kCommentFieldNumber;
+const int ClientDownloadReport::kDownloadResponseFieldNumber;
+#endif  // !_MSC_VER
+
+ClientDownloadReport::ClientDownloadReport()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientDownloadReport)
+}
+
+void ClientDownloadReport::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  download_request_ = const_cast< ::safe_browsing::ClientDownloadRequest*>(
+      ::safe_browsing::ClientDownloadRequest::internal_default_instance());
+#else
+  download_request_ = const_cast< ::safe_browsing::ClientDownloadRequest*>(&::safe_browsing::ClientDownloadRequest::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  user_information_ = const_cast< ::safe_browsing::ClientDownloadReport_UserInformation*>(
+      ::safe_browsing::ClientDownloadReport_UserInformation::internal_default_instance());
+#else
+  user_information_ = const_cast< ::safe_browsing::ClientDownloadReport_UserInformation*>(&::safe_browsing::ClientDownloadReport_UserInformation::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  download_response_ = const_cast< ::safe_browsing::ClientDownloadResponse*>(
+      ::safe_browsing::ClientDownloadResponse::internal_default_instance());
+#else
+  download_response_ = const_cast< ::safe_browsing::ClientDownloadResponse*>(&::safe_browsing::ClientDownloadResponse::default_instance());
+#endif
+}
+
+ClientDownloadReport::ClientDownloadReport(const ClientDownloadReport& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientDownloadReport)
+}
+
+void ClientDownloadReport::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  reason_ = 0;
+  download_request_ = NULL;
+  user_information_ = NULL;
+  comment_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  download_response_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientDownloadReport::~ClientDownloadReport() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientDownloadReport)
+  SharedDtor();
+}
+
+void ClientDownloadReport::SharedDtor() {
+  if (comment_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete comment_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete download_request_;
+    delete user_information_;
+    delete download_response_;
+  }
+}
+
+void ClientDownloadReport::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientDownloadReport& ClientDownloadReport::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientDownloadReport* ClientDownloadReport::default_instance_ = NULL;
+
+ClientDownloadReport* ClientDownloadReport::New() const {
+  return new ClientDownloadReport;
+}
+
+void ClientDownloadReport::Clear() {
+  if (_has_bits_[0 / 32] & 31) {
+    reason_ = 0;
+    if (has_download_request()) {
+      if (download_request_ != NULL) download_request_->::safe_browsing::ClientDownloadRequest::Clear();
+    }
+    if (has_user_information()) {
+      if (user_information_ != NULL) user_information_->::safe_browsing::ClientDownloadReport_UserInformation::Clear();
+    }
+    if (has_comment()) {
+      if (comment_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        comment_->clear();
+      }
+    }
+    if (has_download_response()) {
+      if (download_response_ != NULL) download_response_->::safe_browsing::ClientDownloadResponse::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientDownloadReport::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientDownloadReport)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .safe_browsing.ClientDownloadReport.Reason reason = 1;
+      case 1: {
+        if (tag == 8) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientDownloadReport_Reason_IsValid(value)) {
+            set_reason(static_cast< ::safe_browsing::ClientDownloadReport_Reason >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_download_request;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest download_request = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_download_request:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_download_request()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_user_information;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_user_information:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_user_information()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_comment;
+        break;
+      }
+
+      // optional bytes comment = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_comment:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_comment()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_download_response;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadResponse download_response = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_download_response:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_download_response()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientDownloadReport)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientDownloadReport)
+  return false;
+#undef DO_
+}
+
+void ClientDownloadReport::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientDownloadReport)
+  // optional .safe_browsing.ClientDownloadReport.Reason reason = 1;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->reason(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest download_request = 2;
+  if (has_download_request()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->download_request(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3;
+  if (has_user_information()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->user_information(), output);
+  }
+
+  // optional bytes comment = 4;
+  if (has_comment()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      4, this->comment(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadResponse download_response = 5;
+  if (has_download_response()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      5, this->download_response(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientDownloadReport)
+}
+
+int ClientDownloadReport::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .safe_browsing.ClientDownloadReport.Reason reason = 1;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->reason());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest download_request = 2;
+    if (has_download_request()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->download_request());
+    }
+
+    // optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3;
+    if (has_user_information()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->user_information());
+    }
+
+    // optional bytes comment = 4;
+    if (has_comment()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->comment());
+    }
+
+    // optional .safe_browsing.ClientDownloadResponse download_response = 5;
+    if (has_download_response()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->download_response());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientDownloadReport::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientDownloadReport*>(&from));
+}
+
+void ClientDownloadReport::MergeFrom(const ClientDownloadReport& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+    if (from.has_download_request()) {
+      mutable_download_request()->::safe_browsing::ClientDownloadRequest::MergeFrom(from.download_request());
+    }
+    if (from.has_user_information()) {
+      mutable_user_information()->::safe_browsing::ClientDownloadReport_UserInformation::MergeFrom(from.user_information());
+    }
+    if (from.has_comment()) {
+      set_comment(from.comment());
+    }
+    if (from.has_download_response()) {
+      mutable_download_response()->::safe_browsing::ClientDownloadResponse::MergeFrom(from.download_response());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientDownloadReport::CopyFrom(const ClientDownloadReport& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientDownloadReport::IsInitialized() const {
+
+  if (has_download_request()) {
+    if (!this->download_request().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientDownloadReport::Swap(ClientDownloadReport* other) {
+  if (other != this) {
+    std::swap(reason_, other->reason_);
+    std::swap(download_request_, other->download_request_);
+    std::swap(user_information_, other->user_information_);
+    std::swap(comment_, other->comment_);
+    std::swap(download_response_, other->download_response_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientDownloadReport::GetTypeName() const {
+  return "safe_browsing.ClientDownloadReport";
+}
+
+
+// ===================================================================
+
+bool ClientUploadResponse_UploadStatus_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const ClientUploadResponse_UploadStatus ClientUploadResponse::SUCCESS;
+const ClientUploadResponse_UploadStatus ClientUploadResponse::UPLOAD_FAILURE;
+const ClientUploadResponse_UploadStatus ClientUploadResponse::UploadStatus_MIN;
+const ClientUploadResponse_UploadStatus ClientUploadResponse::UploadStatus_MAX;
+const int ClientUploadResponse::UploadStatus_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ClientUploadResponse::kStatusFieldNumber;
+const int ClientUploadResponse::kPermalinkFieldNumber;
+#endif  // !_MSC_VER
+
+ClientUploadResponse::ClientUploadResponse()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientUploadResponse)
+}
+
+void ClientUploadResponse::InitAsDefaultInstance() {
+}
+
+ClientUploadResponse::ClientUploadResponse(const ClientUploadResponse& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientUploadResponse)
+}
+
+void ClientUploadResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  status_ = 0;
+  permalink_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientUploadResponse::~ClientUploadResponse() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientUploadResponse)
+  SharedDtor();
+}
+
+void ClientUploadResponse::SharedDtor() {
+  if (permalink_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete permalink_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientUploadResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientUploadResponse& ClientUploadResponse::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientUploadResponse* ClientUploadResponse::default_instance_ = NULL;
+
+ClientUploadResponse* ClientUploadResponse::New() const {
+  return new ClientUploadResponse;
+}
+
+void ClientUploadResponse::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    status_ = 0;
+    if (has_permalink()) {
+      if (permalink_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        permalink_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientUploadResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientUploadResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1;
+      case 1: {
+        if (tag == 8) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientUploadResponse_UploadStatus_IsValid(value)) {
+            set_status(static_cast< ::safe_browsing::ClientUploadResponse_UploadStatus >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_permalink;
+        break;
+      }
+
+      // optional string permalink = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_permalink:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_permalink()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientUploadResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientUploadResponse)
+  return false;
+#undef DO_
+}
+
+void ClientUploadResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientUploadResponse)
+  // optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1;
+  if (has_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->status(), output);
+  }
+
+  // optional string permalink = 2;
+  if (has_permalink()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->permalink(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientUploadResponse)
+}
+
+int ClientUploadResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1;
+    if (has_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
+    }
+
+    // optional string permalink = 2;
+    if (has_permalink()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->permalink());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientUploadResponse::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientUploadResponse*>(&from));
+}
+
+void ClientUploadResponse::MergeFrom(const ClientUploadResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_status()) {
+      set_status(from.status());
+    }
+    if (from.has_permalink()) {
+      set_permalink(from.permalink());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientUploadResponse::CopyFrom(const ClientUploadResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientUploadResponse::IsInitialized() const {
+
+  return true;
+}
+
+void ClientUploadResponse::Swap(ClientUploadResponse* other) {
+  if (other != this) {
+    std::swap(status_, other->status_);
+    std::swap(permalink_, other->permalink_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientUploadResponse::GetTypeName() const {
+  return "safe_browsing.ClientUploadResponse";
+}
+
+
+// ===================================================================
+
+bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::UNKNOWN;
+const ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::CLEARED;
+const ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::WEAK_LEGACY_OBSOLETE;
+const ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::CHANGED;
+const ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::UNTRUSTED_UNKNOWN_VALUE;
+const ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ValueState_MIN;
+const ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ValueState_MAX;
+const int ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ValueState_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ClientIncidentReport_IncidentData_TrackedPreferenceIncident::kPathFieldNumber;
+const int ClientIncidentReport_IncidentData_TrackedPreferenceIncident::kAtomicValueFieldNumber;
+const int ClientIncidentReport_IncidentData_TrackedPreferenceIncident::kSplitKeyFieldNumber;
+const int ClientIncidentReport_IncidentData_TrackedPreferenceIncident::kValueStateFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ClientIncidentReport_IncidentData_TrackedPreferenceIncident()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ClientIncidentReport_IncidentData_TrackedPreferenceIncident(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  atomic_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  value_state_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_IncidentData_TrackedPreferenceIncident::~ClientIncidentReport_IncidentData_TrackedPreferenceIncident() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+  SharedDtor();
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::SharedDtor() {
+  if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete path_;
+  }
+  if (atomic_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete atomic_value_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& ClientIncidentReport_IncidentData_TrackedPreferenceIncident::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_IncidentData_TrackedPreferenceIncident* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::default_instance_ = NULL;
+
+ClientIncidentReport_IncidentData_TrackedPreferenceIncident* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::New() const {
+  return new ClientIncidentReport_IncidentData_TrackedPreferenceIncident;
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::Clear() {
+  if (_has_bits_[0 / 32] & 11) {
+    if (has_path()) {
+      if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        path_->clear();
+      }
+    }
+    if (has_atomic_value()) {
+      if (atomic_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        atomic_value_->clear();
+      }
+    }
+    value_state_ = 0;
+  }
+  split_key_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string path = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_path()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_atomic_value;
+        break;
+      }
+
+      // optional string atomic_value = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_atomic_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_atomic_value()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_split_key;
+        break;
+      }
+
+      // repeated string split_key = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_split_key:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_split_key()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_split_key;
+        if (input->ExpectTag(32)) goto parse_value_state;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.ValueState value_state = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_value_state:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_IsValid(value)) {
+            set_value_state(static_cast< ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+  // optional string path = 1;
+  if (has_path()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->path(), output);
+  }
+
+  // optional string atomic_value = 2;
+  if (has_atomic_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->atomic_value(), output);
+  }
+
+  // repeated string split_key = 3;
+  for (int i = 0; i < this->split_key_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->split_key(i), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.ValueState value_state = 4;
+  if (has_value_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      4, this->value_state(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+}
+
+int ClientIncidentReport_IncidentData_TrackedPreferenceIncident::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string path = 1;
+    if (has_path()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->path());
+    }
+
+    // optional string atomic_value = 2;
+    if (has_atomic_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->atomic_value());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.ValueState value_state = 4;
+    if (has_value_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->value_state());
+    }
+
+  }
+  // repeated string split_key = 3;
+  total_size += 1 * this->split_key_size();
+  for (int i = 0; i < this->split_key_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->split_key(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_IncidentData_TrackedPreferenceIncident*>(&from));
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::MergeFrom(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  split_key_.MergeFrom(from.split_key_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_path()) {
+      set_path(from.path());
+    }
+    if (from.has_atomic_value()) {
+      set_atomic_value(from.atomic_value());
+    }
+    if (from.has_value_state()) {
+      set_value_state(from.value_state());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::CopyFrom(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::Swap(ClientIncidentReport_IncidentData_TrackedPreferenceIncident* other) {
+  if (other != this) {
+    std::swap(path_, other->path_);
+    std::swap(atomic_value_, other->atomic_value_);
+    split_key_.Swap(&other->split_key_);
+    std::swap(value_state_, other->value_state_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_IncidentData_TrackedPreferenceIncident::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::kRelativePathFieldNumber;
+const int ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::kSignatureFieldNumber;
+const int ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::kImageHeadersFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>(
+      ::safe_browsing::ClientDownloadRequest_SignatureInfo::internal_default_instance());
+#else
+  signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>(&::safe_browsing::ClientDownloadRequest_SignatureInfo::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(
+      ::safe_browsing::ClientDownloadRequest_ImageHeaders::internal_default_instance());
+#else
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(&::safe_browsing::ClientDownloadRequest_ImageHeaders::default_instance());
+#endif
+}
+
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  relative_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  signature_ = NULL;
+  image_headers_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+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() {
+  if (relative_path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete relative_path_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete signature_;
+    delete image_headers_;
+  }
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::default_instance_ = NULL;
+
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::New() const {
+  return new ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile;
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_relative_path()) {
+      if (relative_path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        relative_path_->clear();
+      }
+    }
+    if (has_signature()) {
+      if (signature_ != NULL) signature_->::safe_browsing::ClientDownloadRequest_SignatureInfo::Clear();
+    }
+    if (has_image_headers()) {
+      if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string relative_path = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_relative_path()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_signature;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_signature:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_signature()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_image_headers;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_image_headers:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_image_headers()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+  // optional string relative_path = 1;
+  if (has_relative_path()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->relative_path(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+  if (has_signature()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->signature(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+  if (has_image_headers()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->image_headers(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+}
+
+int ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string relative_path = 1;
+    if (has_relative_path()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->relative_path());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+    if (has_signature()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->signature());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+    if (has_image_headers()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->image_headers());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile*>(&from));
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::MergeFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_relative_path()) {
+      set_relative_path(from.relative_path());
+    }
+    if (from.has_signature()) {
+      mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(from.signature());
+    }
+    if (from.has_image_headers()) {
+      mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(from.image_headers());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::CopyFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::IsInitialized() const {
+
+  if (has_signature()) {
+    if (!this->signature().IsInitialized()) return false;
+  }
+  if (has_image_headers()) {
+    if (!this->image_headers().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::Swap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* other) {
+  if (other != this) {
+    std::swap(relative_path_, other->relative_path_);
+    std::swap(signature_, other->signature_);
+    std::swap(image_headers_, other->image_headers_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_IncidentData_BinaryIntegrityIncident::kFileBasenameFieldNumber;
+const int ClientIncidentReport_IncidentData_BinaryIntegrityIncident::kSignatureFieldNumber;
+const int ClientIncidentReport_IncidentData_BinaryIntegrityIncident::kImageHeadersFieldNumber;
+const int ClientIncidentReport_IncidentData_BinaryIntegrityIncident::kSecErrorFieldNumber;
+const int ClientIncidentReport_IncidentData_BinaryIntegrityIncident::kContainedFileFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident::ClientIncidentReport_IncidentData_BinaryIntegrityIncident()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>(
+      ::safe_browsing::ClientDownloadRequest_SignatureInfo::internal_default_instance());
+#else
+  signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>(&::safe_browsing::ClientDownloadRequest_SignatureInfo::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(
+      ::safe_browsing::ClientDownloadRequest_ImageHeaders::internal_default_instance());
+#else
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(&::safe_browsing::ClientDownloadRequest_ImageHeaders::default_instance());
+#endif
+}
+
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident::ClientIncidentReport_IncidentData_BinaryIntegrityIncident(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  file_basename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  signature_ = NULL;
+  image_headers_ = NULL;
+  sec_error_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident::~ClientIncidentReport_IncidentData_BinaryIntegrityIncident() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+  SharedDtor();
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::SharedDtor() {
+  if (file_basename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete file_basename_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete signature_;
+    delete image_headers_;
+  }
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::default_instance_ = NULL;
+
+ClientIncidentReport_IncidentData_BinaryIntegrityIncident* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::New() const {
+  return new ClientIncidentReport_IncidentData_BinaryIntegrityIncident;
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_file_basename()) {
+      if (file_basename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        file_basename_->clear();
+      }
+    }
+    if (has_signature()) {
+      if (signature_ != NULL) signature_->::safe_browsing::ClientDownloadRequest_SignatureInfo::Clear();
+    }
+    if (has_image_headers()) {
+      if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+    }
+    sec_error_ = 0;
+  }
+  contained_file_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string file_basename = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_file_basename()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_signature;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_signature:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_signature()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_image_headers;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_image_headers:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_image_headers()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_sec_error;
+        break;
+      }
+
+      // optional int32 sec_error = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_sec_error:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &sec_error_)));
+          set_has_sec_error();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_contained_file;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile contained_file = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_contained_file:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_contained_file()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_contained_file;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+  // optional string file_basename = 1;
+  if (has_file_basename()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->file_basename(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+  if (has_signature()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->signature(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+  if (has_image_headers()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->image_headers(), output);
+  }
+
+  // optional int32 sec_error = 4;
+  if (has_sec_error()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->sec_error(), output);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile contained_file = 5;
+  for (int i = 0; i < this->contained_file_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      5, this->contained_file(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+}
+
+int ClientIncidentReport_IncidentData_BinaryIntegrityIncident::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string file_basename = 1;
+    if (has_file_basename()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->file_basename());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+    if (has_signature()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->signature());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+    if (has_image_headers()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->image_headers());
+    }
+
+    // optional int32 sec_error = 4;
+    if (has_sec_error()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->sec_error());
+    }
+
+  }
+  // repeated .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile contained_file = 5;
+  total_size += 1 * this->contained_file_size();
+  for (int i = 0; i < this->contained_file_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->contained_file(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_IncidentData_BinaryIntegrityIncident*>(&from));
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::MergeFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  contained_file_.MergeFrom(from.contained_file_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_file_basename()) {
+      set_file_basename(from.file_basename());
+    }
+    if (from.has_signature()) {
+      mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(from.signature());
+    }
+    if (from.has_image_headers()) {
+      mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(from.image_headers());
+    }
+    if (from.has_sec_error()) {
+      set_sec_error(from.sec_error());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::CopyFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_IncidentData_BinaryIntegrityIncident::IsInitialized() const {
+
+  if (has_signature()) {
+    if (!this->signature().IsInitialized()) return false;
+  }
+  if (has_image_headers()) {
+    if (!this->image_headers().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->contained_file())) return false;
+  return true;
+}
+
+void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::Swap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident* other) {
+  if (other != this) {
+    std::swap(file_basename_, other->file_basename_);
+    std::swap(signature_, other->signature_);
+    std::swap(image_headers_, other->image_headers_);
+    std::swap(sec_error_, other->sec_error_);
+    contained_file_.Swap(&other->contained_file_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_IncidentData_BinaryIntegrityIncident::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_IncidentData_BlacklistLoadIncident::kPathFieldNumber;
+const int ClientIncidentReport_IncidentData_BlacklistLoadIncident::kDigestFieldNumber;
+const int ClientIncidentReport_IncidentData_BlacklistLoadIncident::kVersionFieldNumber;
+const int ClientIncidentReport_IncidentData_BlacklistLoadIncident::kBlacklistInitializedFieldNumber;
+const int ClientIncidentReport_IncidentData_BlacklistLoadIncident::kSignatureFieldNumber;
+const int ClientIncidentReport_IncidentData_BlacklistLoadIncident::kImageHeadersFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_IncidentData_BlacklistLoadIncident::ClientIncidentReport_IncidentData_BlacklistLoadIncident()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident)
+}
+
+void ClientIncidentReport_IncidentData_BlacklistLoadIncident::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  digest_ = const_cast< ::safe_browsing::ClientDownloadRequest_Digests*>(
+      ::safe_browsing::ClientDownloadRequest_Digests::internal_default_instance());
+#else
+  digest_ = const_cast< ::safe_browsing::ClientDownloadRequest_Digests*>(&::safe_browsing::ClientDownloadRequest_Digests::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>(
+      ::safe_browsing::ClientDownloadRequest_SignatureInfo::internal_default_instance());
+#else
+  signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>(&::safe_browsing::ClientDownloadRequest_SignatureInfo::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(
+      ::safe_browsing::ClientDownloadRequest_ImageHeaders::internal_default_instance());
+#else
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(&::safe_browsing::ClientDownloadRequest_ImageHeaders::default_instance());
+#endif
+}
+
+ClientIncidentReport_IncidentData_BlacklistLoadIncident::ClientIncidentReport_IncidentData_BlacklistLoadIncident(const ClientIncidentReport_IncidentData_BlacklistLoadIncident& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident)
+}
+
+void ClientIncidentReport_IncidentData_BlacklistLoadIncident::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  digest_ = NULL;
+  version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  blacklist_initialized_ = false;
+  signature_ = NULL;
+  image_headers_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_IncidentData_BlacklistLoadIncident::~ClientIncidentReport_IncidentData_BlacklistLoadIncident() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident)
+  SharedDtor();
+}
+
+void ClientIncidentReport_IncidentData_BlacklistLoadIncident::SharedDtor() {
+  if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete path_;
+  }
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete version_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete digest_;
+    delete signature_;
+    delete image_headers_;
+  }
+}
+
+void ClientIncidentReport_IncidentData_BlacklistLoadIncident::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_IncidentData_BlacklistLoadIncident& ClientIncidentReport_IncidentData_BlacklistLoadIncident::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_IncidentData_BlacklistLoadIncident* ClientIncidentReport_IncidentData_BlacklistLoadIncident::default_instance_ = NULL;
+
+ClientIncidentReport_IncidentData_BlacklistLoadIncident* ClientIncidentReport_IncidentData_BlacklistLoadIncident::New() const {
+  return new ClientIncidentReport_IncidentData_BlacklistLoadIncident;
+}
+
+void ClientIncidentReport_IncidentData_BlacklistLoadIncident::Clear() {
+  if (_has_bits_[0 / 32] & 63) {
+    if (has_path()) {
+      if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        path_->clear();
+      }
+    }
+    if (has_digest()) {
+      if (digest_ != NULL) digest_->::safe_browsing::ClientDownloadRequest_Digests::Clear();
+    }
+    if (has_version()) {
+      if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        version_->clear();
+      }
+    }
+    blacklist_initialized_ = false;
+    if (has_signature()) {
+      if (signature_ != NULL) signature_->::safe_browsing::ClientDownloadRequest_SignatureInfo::Clear();
+    }
+    if (has_image_headers()) {
+      if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_IncidentData_BlacklistLoadIncident::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string path = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_path()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_digest;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.Digests digest = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_digest:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_digest()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_version;
+        break;
+      }
+
+      // optional string version = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_version:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_version()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_blacklist_initialized;
+        break;
+      }
+
+      // optional bool blacklist_initialized = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_blacklist_initialized:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &blacklist_initialized_)));
+          set_has_blacklist_initialized();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_signature;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_signature:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_signature()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_image_headers;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_image_headers:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_image_headers()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_IncidentData_BlacklistLoadIncident::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident)
+  // optional string path = 1;
+  if (has_path()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->path(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.Digests digest = 2;
+  if (has_digest()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->digest(), output);
+  }
+
+  // optional string version = 3;
+  if (has_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->version(), output);
+  }
+
+  // optional bool blacklist_initialized = 4;
+  if (has_blacklist_initialized()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->blacklist_initialized(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+  if (has_signature()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      5, this->signature(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+  if (has_image_headers()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      6, this->image_headers(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident)
+}
+
+int ClientIncidentReport_IncidentData_BlacklistLoadIncident::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string path = 1;
+    if (has_path()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->path());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.Digests digest = 2;
+    if (has_digest()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->digest());
+    }
+
+    // optional string version = 3;
+    if (has_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->version());
+    }
+
+    // optional bool blacklist_initialized = 4;
+    if (has_blacklist_initialized()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+    if (has_signature()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->signature());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+    if (has_image_headers()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->image_headers());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_IncidentData_BlacklistLoadIncident::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_IncidentData_BlacklistLoadIncident*>(&from));
+}
+
+void ClientIncidentReport_IncidentData_BlacklistLoadIncident::MergeFrom(const ClientIncidentReport_IncidentData_BlacklistLoadIncident& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_path()) {
+      set_path(from.path());
+    }
+    if (from.has_digest()) {
+      mutable_digest()->::safe_browsing::ClientDownloadRequest_Digests::MergeFrom(from.digest());
+    }
+    if (from.has_version()) {
+      set_version(from.version());
+    }
+    if (from.has_blacklist_initialized()) {
+      set_blacklist_initialized(from.blacklist_initialized());
+    }
+    if (from.has_signature()) {
+      mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(from.signature());
+    }
+    if (from.has_image_headers()) {
+      mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(from.image_headers());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_IncidentData_BlacklistLoadIncident::CopyFrom(const ClientIncidentReport_IncidentData_BlacklistLoadIncident& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_IncidentData_BlacklistLoadIncident::IsInitialized() const {
+
+  if (has_signature()) {
+    if (!this->signature().IsInitialized()) return false;
+  }
+  if (has_image_headers()) {
+    if (!this->image_headers().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport_IncidentData_BlacklistLoadIncident::Swap(ClientIncidentReport_IncidentData_BlacklistLoadIncident* other) {
+  if (other != this) {
+    std::swap(path_, other->path_);
+    std::swap(digest_, other->digest_);
+    std::swap(version_, other->version_);
+    std::swap(blacklist_initialized_, other->blacklist_initialized_);
+    std::swap(signature_, other->signature_);
+    std::swap(image_headers_, other->image_headers_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_IncidentData_BlacklistLoadIncident::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::kVariationsSeedSignatureFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident)
+}
+
+void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident(const ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident)
+}
+
+void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  variations_seed_signature_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::~ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident)
+  SharedDtor();
+}
+
+void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::SharedDtor() {
+  if (variations_seed_signature_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete variations_seed_signature_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident& ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::default_instance_ = NULL;
+
+ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::New() const {
+  return new ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident;
+}
+
+void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::Clear() {
+  if (has_variations_seed_signature()) {
+    if (variations_seed_signature_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      variations_seed_signature_->clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string variations_seed_signature = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_variations_seed_signature()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident)
+  // optional string variations_seed_signature = 1;
+  if (has_variations_seed_signature()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->variations_seed_signature(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident)
+}
+
+int ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string variations_seed_signature = 1;
+    if (has_variations_seed_signature()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->variations_seed_signature());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident*>(&from));
+}
+
+void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::MergeFrom(const ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_variations_seed_signature()) {
+      set_variations_seed_signature(from.variations_seed_signature());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::CopyFrom(const ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::Swap(ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* other) {
+  if (other != this) {
+    std::swap(variations_seed_signature_, other->variations_seed_signature_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident";
+}
+
+
+// -------------------------------------------------------------------
+
+bool ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident::UNKNOWN;
+const ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident::TYPE_PATTERN;
+const ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident::Type_MIN;
+const ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident::Type_MAX;
+const int ClientIncidentReport_IncidentData_ResourceRequestIncident::Type_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ClientIncidentReport_IncidentData_ResourceRequestIncident::kDigestFieldNumber;
+const int ClientIncidentReport_IncidentData_ResourceRequestIncident::kOriginFieldNumber;
+const int ClientIncidentReport_IncidentData_ResourceRequestIncident::kTypeFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_IncidentData_ResourceRequestIncident::ClientIncidentReport_IncidentData_ResourceRequestIncident()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_IncidentData_ResourceRequestIncident::ClientIncidentReport_IncidentData_ResourceRequestIncident(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  digest_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  origin_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  type_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_IncidentData_ResourceRequestIncident::~ClientIncidentReport_IncidentData_ResourceRequestIncident() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+  SharedDtor();
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::SharedDtor() {
+  if (digest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete digest_;
+  }
+  if (origin_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete origin_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_IncidentData_ResourceRequestIncident& ClientIncidentReport_IncidentData_ResourceRequestIncident::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_IncidentData_ResourceRequestIncident* ClientIncidentReport_IncidentData_ResourceRequestIncident::default_instance_ = NULL;
+
+ClientIncidentReport_IncidentData_ResourceRequestIncident* ClientIncidentReport_IncidentData_ResourceRequestIncident::New() const {
+  return new ClientIncidentReport_IncidentData_ResourceRequestIncident;
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_digest()) {
+      if (digest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        digest_->clear();
+      }
+    }
+    if (has_origin()) {
+      if (origin_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        origin_->clear();
+      }
+    }
+    type_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_IncidentData_ResourceRequestIncident::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes digest = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_digest()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_origin;
+        break;
+      }
+
+      // optional string origin = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_origin:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_origin()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_type;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.Type type = 3 [default = UNKNOWN];
+      case 3: {
+        if (tag == 24) {
+         parse_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_IsValid(value)) {
+            set_type(static_cast< ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+  // optional bytes digest = 1;
+  if (has_digest()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->digest(), output);
+  }
+
+  // optional string origin = 2;
+  if (has_origin()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->origin(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.Type type = 3 [default = UNKNOWN];
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      3, this->type(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+}
+
+int ClientIncidentReport_IncidentData_ResourceRequestIncident::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes digest = 1;
+    if (has_digest()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->digest());
+    }
+
+    // optional string origin = 2;
+    if (has_origin()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->origin());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.Type type = 3 [default = UNKNOWN];
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_IncidentData_ResourceRequestIncident*>(&from));
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::MergeFrom(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_digest()) {
+      set_digest(from.digest());
+    }
+    if (from.has_origin()) {
+      set_origin(from.origin());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::CopyFrom(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_IncidentData_ResourceRequestIncident::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_IncidentData_ResourceRequestIncident::Swap(ClientIncidentReport_IncidentData_ResourceRequestIncident* other) {
+  if (other != this) {
+    std::swap(digest_, other->digest_);
+    std::swap(origin_, other->origin_);
+    std::swap(type_, other->type_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_IncidentData_ResourceRequestIncident::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_IncidentData_SuspiciousModuleIncident::kPathFieldNumber;
+const int ClientIncidentReport_IncidentData_SuspiciousModuleIncident::kDigestFieldNumber;
+const int ClientIncidentReport_IncidentData_SuspiciousModuleIncident::kVersionFieldNumber;
+const int ClientIncidentReport_IncidentData_SuspiciousModuleIncident::kSignatureFieldNumber;
+const int ClientIncidentReport_IncidentData_SuspiciousModuleIncident::kImageHeadersFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_IncidentData_SuspiciousModuleIncident::ClientIncidentReport_IncidentData_SuspiciousModuleIncident()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident)
+}
+
+void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  digest_ = const_cast< ::safe_browsing::ClientDownloadRequest_Digests*>(
+      ::safe_browsing::ClientDownloadRequest_Digests::internal_default_instance());
+#else
+  digest_ = const_cast< ::safe_browsing::ClientDownloadRequest_Digests*>(&::safe_browsing::ClientDownloadRequest_Digests::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>(
+      ::safe_browsing::ClientDownloadRequest_SignatureInfo::internal_default_instance());
+#else
+  signature_ = const_cast< ::safe_browsing::ClientDownloadRequest_SignatureInfo*>(&::safe_browsing::ClientDownloadRequest_SignatureInfo::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(
+      ::safe_browsing::ClientDownloadRequest_ImageHeaders::internal_default_instance());
+#else
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(&::safe_browsing::ClientDownloadRequest_ImageHeaders::default_instance());
+#endif
+}
+
+ClientIncidentReport_IncidentData_SuspiciousModuleIncident::ClientIncidentReport_IncidentData_SuspiciousModuleIncident(const ClientIncidentReport_IncidentData_SuspiciousModuleIncident& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident)
+}
+
+void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  digest_ = NULL;
+  version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  signature_ = NULL;
+  image_headers_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_IncidentData_SuspiciousModuleIncident::~ClientIncidentReport_IncidentData_SuspiciousModuleIncident() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident)
+  SharedDtor();
+}
+
+void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::SharedDtor() {
+  if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete path_;
+  }
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete version_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete digest_;
+    delete signature_;
+    delete image_headers_;
+  }
+}
+
+void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_IncidentData_SuspiciousModuleIncident& ClientIncidentReport_IncidentData_SuspiciousModuleIncident::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_IncidentData_SuspiciousModuleIncident* ClientIncidentReport_IncidentData_SuspiciousModuleIncident::default_instance_ = NULL;
+
+ClientIncidentReport_IncidentData_SuspiciousModuleIncident* ClientIncidentReport_IncidentData_SuspiciousModuleIncident::New() const {
+  return new ClientIncidentReport_IncidentData_SuspiciousModuleIncident;
+}
+
+void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::Clear() {
+  if (_has_bits_[0 / 32] & 31) {
+    if (has_path()) {
+      if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        path_->clear();
+      }
+    }
+    if (has_digest()) {
+      if (digest_ != NULL) digest_->::safe_browsing::ClientDownloadRequest_Digests::Clear();
+    }
+    if (has_version()) {
+      if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        version_->clear();
+      }
+    }
+    if (has_signature()) {
+      if (signature_ != NULL) signature_->::safe_browsing::ClientDownloadRequest_SignatureInfo::Clear();
+    }
+    if (has_image_headers()) {
+      if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_IncidentData_SuspiciousModuleIncident::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string path = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_path()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_digest;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.Digests digest = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_digest:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_digest()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_version;
+        break;
+      }
+
+      // optional string version = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_version:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_version()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_signature;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_signature:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_signature()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_image_headers;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_image_headers:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_image_headers()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident)
+  // optional string path = 1;
+  if (has_path()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->path(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.Digests digest = 2;
+  if (has_digest()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->digest(), output);
+  }
+
+  // optional string version = 3;
+  if (has_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->version(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 4;
+  if (has_signature()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->signature(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+  if (has_image_headers()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      5, this->image_headers(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident)
+}
+
+int ClientIncidentReport_IncidentData_SuspiciousModuleIncident::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string path = 1;
+    if (has_path()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->path());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.Digests digest = 2;
+    if (has_digest()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->digest());
+    }
+
+    // optional string version = 3;
+    if (has_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->version());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 4;
+    if (has_signature()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->signature());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+    if (has_image_headers()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->image_headers());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_IncidentData_SuspiciousModuleIncident*>(&from));
+}
+
+void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::MergeFrom(const ClientIncidentReport_IncidentData_SuspiciousModuleIncident& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_path()) {
+      set_path(from.path());
+    }
+    if (from.has_digest()) {
+      mutable_digest()->::safe_browsing::ClientDownloadRequest_Digests::MergeFrom(from.digest());
+    }
+    if (from.has_version()) {
+      set_version(from.version());
+    }
+    if (from.has_signature()) {
+      mutable_signature()->::safe_browsing::ClientDownloadRequest_SignatureInfo::MergeFrom(from.signature());
+    }
+    if (from.has_image_headers()) {
+      mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(from.image_headers());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::CopyFrom(const ClientIncidentReport_IncidentData_SuspiciousModuleIncident& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_IncidentData_SuspiciousModuleIncident::IsInitialized() const {
+
+  if (has_signature()) {
+    if (!this->signature().IsInitialized()) return false;
+  }
+  if (has_image_headers()) {
+    if (!this->image_headers().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::Swap(ClientIncidentReport_IncidentData_SuspiciousModuleIncident* other) {
+  if (other != this) {
+    std::swap(path_, other->path_);
+    std::swap(digest_, other->digest_);
+    std::swap(version_, other->version_);
+    std::swap(signature_, other->signature_);
+    std::swap(image_headers_, other->image_headers_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_IncidentData_SuspiciousModuleIncident::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_IncidentData::kIncidentTimeMsecFieldNumber;
+const int ClientIncidentReport_IncidentData::kTrackedPreferenceFieldNumber;
+const int ClientIncidentReport_IncidentData::kBinaryIntegrityFieldNumber;
+const int ClientIncidentReport_IncidentData::kBlacklistLoadFieldNumber;
+const int ClientIncidentReport_IncidentData::kVariationsSeedSignatureFieldNumber;
+const int ClientIncidentReport_IncidentData::kResourceRequestFieldNumber;
+const int ClientIncidentReport_IncidentData::kSuspiciousModuleFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_IncidentData::ClientIncidentReport_IncidentData()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.IncidentData)
+}
+
+void ClientIncidentReport_IncidentData::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  tracked_preference_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident*>(
+      ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident::internal_default_instance());
+#else
+  tracked_preference_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident*>(&::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  binary_integrity_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident*>(
+      ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident::internal_default_instance());
+#else
+  binary_integrity_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident*>(&::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  blacklist_load_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident*>(
+      ::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident::internal_default_instance());
+#else
+  blacklist_load_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident*>(&::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  variations_seed_signature_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident*>(
+      ::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::internal_default_instance());
+#else
+  variations_seed_signature_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident*>(&::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  resource_request_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident*>(
+      ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident::internal_default_instance());
+#else
+  resource_request_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident*>(&::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  suspicious_module_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident*>(
+      ::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident::internal_default_instance());
+#else
+  suspicious_module_ = const_cast< ::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident*>(&::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident::default_instance());
+#endif
+}
+
+ClientIncidentReport_IncidentData::ClientIncidentReport_IncidentData(const ClientIncidentReport_IncidentData& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.IncidentData)
+}
+
+void ClientIncidentReport_IncidentData::SharedCtor() {
+  _cached_size_ = 0;
+  incident_time_msec_ = GOOGLE_LONGLONG(0);
+  tracked_preference_ = NULL;
+  binary_integrity_ = NULL;
+  blacklist_load_ = NULL;
+  variations_seed_signature_ = NULL;
+  resource_request_ = NULL;
+  suspicious_module_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_IncidentData::~ClientIncidentReport_IncidentData() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.IncidentData)
+  SharedDtor();
+}
+
+void ClientIncidentReport_IncidentData::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete tracked_preference_;
+    delete binary_integrity_;
+    delete blacklist_load_;
+    delete variations_seed_signature_;
+    delete resource_request_;
+    delete suspicious_module_;
+  }
+}
+
+void ClientIncidentReport_IncidentData::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_IncidentData& ClientIncidentReport_IncidentData::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_IncidentData* ClientIncidentReport_IncidentData::default_instance_ = NULL;
+
+ClientIncidentReport_IncidentData* ClientIncidentReport_IncidentData::New() const {
+  return new ClientIncidentReport_IncidentData;
+}
+
+void ClientIncidentReport_IncidentData::Clear() {
+  if (_has_bits_[0 / 32] & 127) {
+    incident_time_msec_ = GOOGLE_LONGLONG(0);
+    if (has_tracked_preference()) {
+      if (tracked_preference_ != NULL) tracked_preference_->::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident::Clear();
+    }
+    if (has_binary_integrity()) {
+      if (binary_integrity_ != NULL) binary_integrity_->::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident::Clear();
+    }
+    if (has_blacklist_load()) {
+      if (blacklist_load_ != NULL) blacklist_load_->::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident::Clear();
+    }
+    if (has_variations_seed_signature()) {
+      if (variations_seed_signature_ != NULL) variations_seed_signature_->::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::Clear();
+    }
+    if (has_resource_request()) {
+      if (resource_request_ != NULL) resource_request_->::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident::Clear();
+    }
+    if (has_suspicious_module()) {
+      if (suspicious_module_ != NULL) suspicious_module_->::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_IncidentData::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.IncidentData)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional int64 incident_time_msec = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &incident_time_msec_)));
+          set_has_incident_time_msec();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_tracked_preference;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident tracked_preference = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_tracked_preference:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_tracked_preference()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_binary_integrity;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident binary_integrity = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_binary_integrity:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_binary_integrity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_blacklist_load;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident blacklist_load = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_blacklist_load:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_blacklist_load()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_variations_seed_signature;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident variations_seed_signature = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_variations_seed_signature:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_variations_seed_signature()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_resource_request;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident resource_request = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_resource_request:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_resource_request()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_suspicious_module;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident suspicious_module = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_suspicious_module:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_suspicious_module()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.IncidentData)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.IncidentData)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_IncidentData::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.IncidentData)
+  // optional int64 incident_time_msec = 1;
+  if (has_incident_time_msec()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->incident_time_msec(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident tracked_preference = 2;
+  if (has_tracked_preference()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->tracked_preference(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident binary_integrity = 3;
+  if (has_binary_integrity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->binary_integrity(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident blacklist_load = 4;
+  if (has_blacklist_load()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->blacklist_load(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident variations_seed_signature = 6;
+  if (has_variations_seed_signature()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      6, this->variations_seed_signature(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident resource_request = 7;
+  if (has_resource_request()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      7, this->resource_request(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident suspicious_module = 8;
+  if (has_suspicious_module()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      8, this->suspicious_module(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.IncidentData)
+}
+
+int ClientIncidentReport_IncidentData::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional int64 incident_time_msec = 1;
+    if (has_incident_time_msec()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->incident_time_msec());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident tracked_preference = 2;
+    if (has_tracked_preference()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->tracked_preference());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident binary_integrity = 3;
+    if (has_binary_integrity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->binary_integrity());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident blacklist_load = 4;
+    if (has_blacklist_load()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->blacklist_load());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident variations_seed_signature = 6;
+    if (has_variations_seed_signature()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->variations_seed_signature());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident resource_request = 7;
+    if (has_resource_request()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->resource_request());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident suspicious_module = 8;
+    if (has_suspicious_module()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->suspicious_module());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_IncidentData::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_IncidentData*>(&from));
+}
+
+void ClientIncidentReport_IncidentData::MergeFrom(const ClientIncidentReport_IncidentData& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_incident_time_msec()) {
+      set_incident_time_msec(from.incident_time_msec());
+    }
+    if (from.has_tracked_preference()) {
+      mutable_tracked_preference()->::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident::MergeFrom(from.tracked_preference());
+    }
+    if (from.has_binary_integrity()) {
+      mutable_binary_integrity()->::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident::MergeFrom(from.binary_integrity());
+    }
+    if (from.has_blacklist_load()) {
+      mutable_blacklist_load()->::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident::MergeFrom(from.blacklist_load());
+    }
+    if (from.has_variations_seed_signature()) {
+      mutable_variations_seed_signature()->::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::MergeFrom(from.variations_seed_signature());
+    }
+    if (from.has_resource_request()) {
+      mutable_resource_request()->::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident::MergeFrom(from.resource_request());
+    }
+    if (from.has_suspicious_module()) {
+      mutable_suspicious_module()->::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident::MergeFrom(from.suspicious_module());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_IncidentData::CopyFrom(const ClientIncidentReport_IncidentData& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_IncidentData::IsInitialized() const {
+
+  if (has_binary_integrity()) {
+    if (!this->binary_integrity().IsInitialized()) return false;
+  }
+  if (has_blacklist_load()) {
+    if (!this->blacklist_load().IsInitialized()) return false;
+  }
+  if (has_suspicious_module()) {
+    if (!this->suspicious_module().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport_IncidentData::Swap(ClientIncidentReport_IncidentData* other) {
+  if (other != this) {
+    std::swap(incident_time_msec_, other->incident_time_msec_);
+    std::swap(tracked_preference_, other->tracked_preference_);
+    std::swap(binary_integrity_, other->binary_integrity_);
+    std::swap(blacklist_load_, other->blacklist_load_);
+    std::swap(variations_seed_signature_, other->variations_seed_signature_);
+    std::swap(resource_request_, other->resource_request_);
+    std::swap(suspicious_module_, other->suspicious_module_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_IncidentData::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.IncidentData";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_DownloadDetails::kTokenFieldNumber;
+const int ClientIncidentReport_DownloadDetails::kDownloadFieldNumber;
+const int ClientIncidentReport_DownloadDetails::kDownloadTimeMsecFieldNumber;
+const int ClientIncidentReport_DownloadDetails::kOpenTimeMsecFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_DownloadDetails::ClientIncidentReport_DownloadDetails()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.DownloadDetails)
+}
+
+void ClientIncidentReport_DownloadDetails::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  download_ = const_cast< ::safe_browsing::ClientDownloadRequest*>(
+      ::safe_browsing::ClientDownloadRequest::internal_default_instance());
+#else
+  download_ = const_cast< ::safe_browsing::ClientDownloadRequest*>(&::safe_browsing::ClientDownloadRequest::default_instance());
+#endif
+}
+
+ClientIncidentReport_DownloadDetails::ClientIncidentReport_DownloadDetails(const ClientIncidentReport_DownloadDetails& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.DownloadDetails)
+}
+
+void ClientIncidentReport_DownloadDetails::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  download_ = NULL;
+  download_time_msec_ = GOOGLE_LONGLONG(0);
+  open_time_msec_ = GOOGLE_LONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_DownloadDetails::~ClientIncidentReport_DownloadDetails() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.DownloadDetails)
+  SharedDtor();
+}
+
+void ClientIncidentReport_DownloadDetails::SharedDtor() {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete token_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete download_;
+  }
+}
+
+void ClientIncidentReport_DownloadDetails::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_DownloadDetails& ClientIncidentReport_DownloadDetails::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_DownloadDetails* ClientIncidentReport_DownloadDetails::default_instance_ = NULL;
+
+ClientIncidentReport_DownloadDetails* ClientIncidentReport_DownloadDetails::New() const {
+  return new ClientIncidentReport_DownloadDetails;
+}
+
+void ClientIncidentReport_DownloadDetails::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClientIncidentReport_DownloadDetails*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(download_time_msec_, open_time_msec_);
+    if (has_token()) {
+      if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        token_->clear();
+      }
+    }
+    if (has_download()) {
+      if (download_ != NULL) download_->::safe_browsing::ClientDownloadRequest::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_DownloadDetails::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.DownloadDetails)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes token = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_token()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_download;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest download = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_download:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_download()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_download_time_msec;
+        break;
+      }
+
+      // optional int64 download_time_msec = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_download_time_msec:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &download_time_msec_)));
+          set_has_download_time_msec();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_open_time_msec;
+        break;
+      }
+
+      // optional int64 open_time_msec = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_open_time_msec:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &open_time_msec_)));
+          set_has_open_time_msec();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.DownloadDetails)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.DownloadDetails)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_DownloadDetails::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.DownloadDetails)
+  // optional bytes token = 1;
+  if (has_token()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->token(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest download = 2;
+  if (has_download()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->download(), output);
+  }
+
+  // optional int64 download_time_msec = 3;
+  if (has_download_time_msec()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->download_time_msec(), output);
+  }
+
+  // optional int64 open_time_msec = 4;
+  if (has_open_time_msec()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(4, this->open_time_msec(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.DownloadDetails)
+}
+
+int ClientIncidentReport_DownloadDetails::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes token = 1;
+    if (has_token()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->token());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest download = 2;
+    if (has_download()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->download());
+    }
+
+    // optional int64 download_time_msec = 3;
+    if (has_download_time_msec()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->download_time_msec());
+    }
+
+    // optional int64 open_time_msec = 4;
+    if (has_open_time_msec()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->open_time_msec());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_DownloadDetails::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_DownloadDetails*>(&from));
+}
+
+void ClientIncidentReport_DownloadDetails::MergeFrom(const ClientIncidentReport_DownloadDetails& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_token()) {
+      set_token(from.token());
+    }
+    if (from.has_download()) {
+      mutable_download()->::safe_browsing::ClientDownloadRequest::MergeFrom(from.download());
+    }
+    if (from.has_download_time_msec()) {
+      set_download_time_msec(from.download_time_msec());
+    }
+    if (from.has_open_time_msec()) {
+      set_open_time_msec(from.open_time_msec());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_DownloadDetails::CopyFrom(const ClientIncidentReport_DownloadDetails& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_DownloadDetails::IsInitialized() const {
+
+  if (has_download()) {
+    if (!this->download().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport_DownloadDetails::Swap(ClientIncidentReport_DownloadDetails* other) {
+  if (other != this) {
+    std::swap(token_, other->token_);
+    std::swap(download_, other->download_);
+    std::swap(download_time_msec_, other->download_time_msec_);
+    std::swap(open_time_msec_, other->open_time_msec_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_DownloadDetails::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.DownloadDetails";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_EnvironmentData_OS_RegistryValue::kNameFieldNumber;
+const int ClientIncidentReport_EnvironmentData_OS_RegistryValue::kTypeFieldNumber;
+const int ClientIncidentReport_EnvironmentData_OS_RegistryValue::kDataFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_EnvironmentData_OS_RegistryValue::ClientIncidentReport_EnvironmentData_OS_RegistryValue()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_EnvironmentData_OS_RegistryValue::ClientIncidentReport_EnvironmentData_OS_RegistryValue(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  type_ = 0u;
+  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+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() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete data_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_EnvironmentData_OS_RegistryValue& ClientIncidentReport_EnvironmentData_OS_RegistryValue::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_EnvironmentData_OS_RegistryValue* ClientIncidentReport_EnvironmentData_OS_RegistryValue::default_instance_ = NULL;
+
+ClientIncidentReport_EnvironmentData_OS_RegistryValue* ClientIncidentReport_EnvironmentData_OS_RegistryValue::New() const {
+  return new ClientIncidentReport_EnvironmentData_OS_RegistryValue;
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    type_ = 0u;
+    if (has_data()) {
+      if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        data_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_EnvironmentData_OS_RegistryValue::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string name = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_type;
+        break;
+      }
+
+      // optional uint32 type = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_type:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &type_)));
+          set_has_type();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_data;
+        break;
+      }
+
+      // optional bytes data = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_data:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+  // optional string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->name(), output);
+  }
+
+  // optional uint32 type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->type(), output);
+  }
+
+  // optional bytes data = 3;
+  if (has_data()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->data(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+}
+
+int ClientIncidentReport_EnvironmentData_OS_RegistryValue::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string name = 1;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional uint32 type = 2;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->type());
+    }
+
+    // optional bytes data = 3;
+    if (has_data()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->data());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_EnvironmentData_OS_RegistryValue*>(&from));
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::MergeFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_data()) {
+      set_data(from.data());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::CopyFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_OS_RegistryValue::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryValue::Swap(ClientIncidentReport_EnvironmentData_OS_RegistryValue* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    std::swap(type_, other->type_);
+    std::swap(data_, other->data_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_EnvironmentData_OS_RegistryValue::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_EnvironmentData_OS_RegistryKey::kNameFieldNumber;
+const int ClientIncidentReport_EnvironmentData_OS_RegistryKey::kValueFieldNumber;
+const int ClientIncidentReport_EnvironmentData_OS_RegistryKey::kKeyFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_EnvironmentData_OS_RegistryKey::ClientIncidentReport_EnvironmentData_OS_RegistryKey()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_EnvironmentData_OS_RegistryKey::ClientIncidentReport_EnvironmentData_OS_RegistryKey(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+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() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_EnvironmentData_OS_RegistryKey& ClientIncidentReport_EnvironmentData_OS_RegistryKey::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_EnvironmentData_OS_RegistryKey* ClientIncidentReport_EnvironmentData_OS_RegistryKey::default_instance_ = NULL;
+
+ClientIncidentReport_EnvironmentData_OS_RegistryKey* ClientIncidentReport_EnvironmentData_OS_RegistryKey::New() const {
+  return new ClientIncidentReport_EnvironmentData_OS_RegistryKey;
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::Clear() {
+  if (has_name()) {
+    if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      name_->clear();
+    }
+  }
+  value_.Clear();
+  key_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_EnvironmentData_OS_RegistryKey::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string name = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_value;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue value = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_value()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_value;
+        if (input->ExpectTag(26)) goto parse_key;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey key = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_key:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_key()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_key;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+  // optional string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->name(), output);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue value = 2;
+  for (int i = 0; i < this->value_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->value(i), output);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey key = 3;
+  for (int i = 0; i < this->key_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->key(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+}
+
+int ClientIncidentReport_EnvironmentData_OS_RegistryKey::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string name = 1;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+  }
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue value = 2;
+  total_size += 1 * this->value_size();
+  for (int i = 0; i < this->value_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->value(i));
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey key = 3;
+  total_size += 1 * this->key_size();
+  for (int i = 0; i < this->key_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->key(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_EnvironmentData_OS_RegistryKey*>(&from));
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::MergeFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  value_.MergeFrom(from.value_);
+  key_.MergeFrom(from.key_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::CopyFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_OS_RegistryKey::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_OS_RegistryKey::Swap(ClientIncidentReport_EnvironmentData_OS_RegistryKey* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    value_.Swap(&other->value_);
+    key_.Swap(&other->key_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_EnvironmentData_OS_RegistryKey::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_EnvironmentData_OS::kOsNameFieldNumber;
+const int ClientIncidentReport_EnvironmentData_OS::kOsVersionFieldNumber;
+const int ClientIncidentReport_EnvironmentData_OS::kRegistryKeyFieldNumber;
+const int ClientIncidentReport_EnvironmentData_OS::kIsEnrolledToDomainFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_EnvironmentData_OS::ClientIncidentReport_EnvironmentData_OS()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+}
+
+void ClientIncidentReport_EnvironmentData_OS::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_EnvironmentData_OS::ClientIncidentReport_EnvironmentData_OS(const ClientIncidentReport_EnvironmentData_OS& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+}
+
+void ClientIncidentReport_EnvironmentData_OS::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  os_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  os_version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  is_enrolled_to_domain_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_EnvironmentData_OS::~ClientIncidentReport_EnvironmentData_OS() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+  SharedDtor();
+}
+
+void ClientIncidentReport_EnvironmentData_OS::SharedDtor() {
+  if (os_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete os_name_;
+  }
+  if (os_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete os_version_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_EnvironmentData_OS::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_EnvironmentData_OS& ClientIncidentReport_EnvironmentData_OS::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_EnvironmentData_OS* ClientIncidentReport_EnvironmentData_OS::default_instance_ = NULL;
+
+ClientIncidentReport_EnvironmentData_OS* ClientIncidentReport_EnvironmentData_OS::New() const {
+  return new ClientIncidentReport_EnvironmentData_OS;
+}
+
+void ClientIncidentReport_EnvironmentData_OS::Clear() {
+  if (_has_bits_[0 / 32] & 11) {
+    if (has_os_name()) {
+      if (os_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        os_name_->clear();
+      }
+    }
+    if (has_os_version()) {
+      if (os_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        os_version_->clear();
+      }
+    }
+    is_enrolled_to_domain_ = false;
+  }
+  registry_key_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_EnvironmentData_OS::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string os_name = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_os_name()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_os_version;
+        break;
+      }
+
+      // optional string os_version = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_os_version:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_os_version()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_registry_key;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey registry_key = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_registry_key:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_registry_key()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_registry_key;
+        if (input->ExpectTag(32)) goto parse_is_enrolled_to_domain;
+        break;
+      }
+
+      // optional bool is_enrolled_to_domain = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_is_enrolled_to_domain:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_enrolled_to_domain_)));
+          set_has_is_enrolled_to_domain();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_EnvironmentData_OS::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+  // optional string os_name = 1;
+  if (has_os_name()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->os_name(), output);
+  }
+
+  // optional string os_version = 2;
+  if (has_os_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->os_version(), output);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey registry_key = 3;
+  for (int i = 0; i < this->registry_key_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->registry_key(i), output);
+  }
+
+  // optional bool is_enrolled_to_domain = 4;
+  if (has_is_enrolled_to_domain()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_enrolled_to_domain(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+}
+
+int ClientIncidentReport_EnvironmentData_OS::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string os_name = 1;
+    if (has_os_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->os_name());
+    }
+
+    // optional string os_version = 2;
+    if (has_os_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->os_version());
+    }
+
+    // optional bool is_enrolled_to_domain = 4;
+    if (has_is_enrolled_to_domain()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey registry_key = 3;
+  total_size += 1 * this->registry_key_size();
+  for (int i = 0; i < this->registry_key_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->registry_key(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_OS::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_EnvironmentData_OS*>(&from));
+}
+
+void ClientIncidentReport_EnvironmentData_OS::MergeFrom(const ClientIncidentReport_EnvironmentData_OS& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  registry_key_.MergeFrom(from.registry_key_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_os_name()) {
+      set_os_name(from.os_name());
+    }
+    if (from.has_os_version()) {
+      set_os_version(from.os_version());
+    }
+    if (from.has_is_enrolled_to_domain()) {
+      set_is_enrolled_to_domain(from.is_enrolled_to_domain());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_EnvironmentData_OS::CopyFrom(const ClientIncidentReport_EnvironmentData_OS& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_OS::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_OS::Swap(ClientIncidentReport_EnvironmentData_OS* other) {
+  if (other != this) {
+    std::swap(os_name_, other->os_name_);
+    std::swap(os_version_, other->os_version_);
+    registry_key_.Swap(&other->registry_key_);
+    std::swap(is_enrolled_to_domain_, other->is_enrolled_to_domain_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_EnvironmentData_OS::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.OS";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_EnvironmentData_Machine::kCpuArchitectureFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Machine::kCpuVendorFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Machine::kCpuidFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_EnvironmentData_Machine::ClientIncidentReport_EnvironmentData_Machine()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_EnvironmentData_Machine::ClientIncidentReport_EnvironmentData_Machine(const ClientIncidentReport_EnvironmentData_Machine& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  cpu_architecture_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  cpu_vendor_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  cpuid_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_EnvironmentData_Machine::~ClientIncidentReport_EnvironmentData_Machine() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+  SharedDtor();
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::SharedDtor() {
+  if (cpu_architecture_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete cpu_architecture_;
+  }
+  if (cpu_vendor_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete cpu_vendor_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_EnvironmentData_Machine& ClientIncidentReport_EnvironmentData_Machine::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_EnvironmentData_Machine* ClientIncidentReport_EnvironmentData_Machine::default_instance_ = NULL;
+
+ClientIncidentReport_EnvironmentData_Machine* ClientIncidentReport_EnvironmentData_Machine::New() const {
+  return new ClientIncidentReport_EnvironmentData_Machine;
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_cpu_architecture()) {
+      if (cpu_architecture_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        cpu_architecture_->clear();
+      }
+    }
+    if (has_cpu_vendor()) {
+      if (cpu_vendor_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        cpu_vendor_->clear();
+      }
+    }
+    cpuid_ = 0u;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_EnvironmentData_Machine::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string cpu_architecture = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_cpu_architecture()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_cpu_vendor;
+        break;
+      }
+
+      // optional string cpu_vendor = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_cpu_vendor:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_cpu_vendor()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_cpuid;
+        break;
+      }
+
+      // optional uint32 cpuid = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_cpuid:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &cpuid_)));
+          set_has_cpuid();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+  // optional string cpu_architecture = 1;
+  if (has_cpu_architecture()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->cpu_architecture(), output);
+  }
+
+  // optional string cpu_vendor = 2;
+  if (has_cpu_vendor()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->cpu_vendor(), output);
+  }
+
+  // optional uint32 cpuid = 3;
+  if (has_cpuid()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->cpuid(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+}
+
+int ClientIncidentReport_EnvironmentData_Machine::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string cpu_architecture = 1;
+    if (has_cpu_architecture()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->cpu_architecture());
+    }
+
+    // optional string cpu_vendor = 2;
+    if (has_cpu_vendor()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->cpu_vendor());
+    }
+
+    // optional uint32 cpuid = 3;
+    if (has_cpuid()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->cpuid());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_EnvironmentData_Machine*>(&from));
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::MergeFrom(const ClientIncidentReport_EnvironmentData_Machine& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_cpu_architecture()) {
+      set_cpu_architecture(from.cpu_architecture());
+    }
+    if (from.has_cpu_vendor()) {
+      set_cpu_vendor(from.cpu_vendor());
+    }
+    if (from.has_cpuid()) {
+      set_cpuid(from.cpuid());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::CopyFrom(const ClientIncidentReport_EnvironmentData_Machine& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Machine::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Machine::Swap(ClientIncidentReport_EnvironmentData_Machine* other) {
+  if (other != this) {
+    std::swap(cpu_architecture_, other->cpu_architecture_);
+    std::swap(cpu_vendor_, other->cpu_vendor_);
+    std::swap(cpuid_, other->cpuid_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_EnvironmentData_Machine::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Machine";
+}
+
+
+// -------------------------------------------------------------------
+
+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;
+  }
+}
+
+#ifndef _MSC_VER
+const ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::CHANNEL_UNKNOWN;
+const ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::CHANNEL_CANARY;
+const ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::CHANNEL_DEV;
+const ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::CHANNEL_BETA;
+const ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::CHANNEL_STABLE;
+const ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::Channel_MIN;
+const ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process::Channel_MAX;
+const int ClientIncidentReport_EnvironmentData_Process::Channel_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ClientIncidentReport_EnvironmentData_Process_Patch::kFunctionFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process_Patch::kTargetDllFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_EnvironmentData_Process_Patch::ClientIncidentReport_EnvironmentData_Process_Patch()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_EnvironmentData_Process_Patch::ClientIncidentReport_EnvironmentData_Process_Patch(const ClientIncidentReport_EnvironmentData_Process_Patch& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  function_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  target_dll_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+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() {
+  if (function_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete function_;
+  }
+  if (target_dll_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete target_dll_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_EnvironmentData_Process_Patch& ClientIncidentReport_EnvironmentData_Process_Patch::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_EnvironmentData_Process_Patch* ClientIncidentReport_EnvironmentData_Process_Patch::default_instance_ = NULL;
+
+ClientIncidentReport_EnvironmentData_Process_Patch* ClientIncidentReport_EnvironmentData_Process_Patch::New() const {
+  return new ClientIncidentReport_EnvironmentData_Process_Patch;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_function()) {
+      if (function_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        function_->clear();
+      }
+    }
+    if (has_target_dll()) {
+      if (target_dll_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        target_dll_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_Patch::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string function = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_function()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_target_dll;
+        break;
+      }
+
+      // optional string target_dll = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_target_dll:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_target_dll()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+  // optional string function = 1;
+  if (has_function()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->function(), output);
+  }
+
+  // optional string target_dll = 2;
+  if (has_target_dll()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->target_dll(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+}
+
+int ClientIncidentReport_EnvironmentData_Process_Patch::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string function = 1;
+    if (has_function()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->function());
+    }
+
+    // optional string target_dll = 2;
+    if (has_target_dll()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->target_dll());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_EnvironmentData_Process_Patch*>(&from));
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_Patch& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_function()) {
+      set_function(from.function());
+    }
+    if (from.has_target_dll()) {
+      set_target_dll(from.target_dll());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::CopyFrom(const ClientIncidentReport_EnvironmentData_Process_Patch& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_Patch::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Patch::Swap(ClientIncidentReport_EnvironmentData_Process_Patch* other) {
+  if (other != this) {
+    std::swap(function_, other->function_);
+    std::swap(target_dll_, other->target_dll_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_EnvironmentData_Process_Patch::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+#endif  // !_MSC_VER
+
+ClientIncidentReport_EnvironmentData_Process_NetworkProvider::ClientIncidentReport_EnvironmentData_Process_NetworkProvider()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_EnvironmentData_Process_NetworkProvider::ClientIncidentReport_EnvironmentData_Process_NetworkProvider(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+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() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& ClientIncidentReport_EnvironmentData_Process_NetworkProvider::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_EnvironmentData_Process_NetworkProvider* ClientIncidentReport_EnvironmentData_Process_NetworkProvider::default_instance_ = NULL;
+
+ClientIncidentReport_EnvironmentData_Process_NetworkProvider* ClientIncidentReport_EnvironmentData_Process_NetworkProvider::New() const {
+  return new ClientIncidentReport_EnvironmentData_Process_NetworkProvider;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::Clear() {
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_NetworkProvider::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+  handle_unusual:
+    if (tag == 0 ||
+        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+      goto success;
+    }
+    DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+        input, tag, &unknown_fields_stream));
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+}
+
+int ClientIncidentReport_EnvironmentData_Process_NetworkProvider::ByteSize() const {
+  int total_size = 0;
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_EnvironmentData_Process_NetworkProvider*>(&from));
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::CopyFrom(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_NetworkProvider::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_NetworkProvider::Swap(ClientIncidentReport_EnvironmentData_Process_NetworkProvider* other) {
+  if (other != this) {
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_EnvironmentData_Process_NetworkProvider::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider";
+}
+
+
+// -------------------------------------------------------------------
+
+bool ClientIncidentReport_EnvironmentData_Process_Dll_Feature_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll::UNKNOWN;
+const ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll::LSP;
+const ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll::Feature_MIN;
+const ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll::Feature_MAX;
+const int ClientIncidentReport_EnvironmentData_Process_Dll::Feature_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ClientIncidentReport_EnvironmentData_Process_Dll::kPathFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process_Dll::kBaseAddressFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process_Dll::kLengthFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process_Dll::kFeatureFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process_Dll::kImageHeadersFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_EnvironmentData_Process_Dll::ClientIncidentReport_EnvironmentData_Process_Dll()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(
+      ::safe_browsing::ClientDownloadRequest_ImageHeaders::internal_default_instance());
+#else
+  image_headers_ = const_cast< ::safe_browsing::ClientDownloadRequest_ImageHeaders*>(&::safe_browsing::ClientDownloadRequest_ImageHeaders::default_instance());
+#endif
+}
+
+ClientIncidentReport_EnvironmentData_Process_Dll::ClientIncidentReport_EnvironmentData_Process_Dll(const ClientIncidentReport_EnvironmentData_Process_Dll& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  base_address_ = GOOGLE_ULONGLONG(0);
+  length_ = 0u;
+  image_headers_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+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() {
+  if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete path_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete image_headers_;
+  }
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_EnvironmentData_Process_Dll& ClientIncidentReport_EnvironmentData_Process_Dll::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_EnvironmentData_Process_Dll* ClientIncidentReport_EnvironmentData_Process_Dll::default_instance_ = NULL;
+
+ClientIncidentReport_EnvironmentData_Process_Dll* ClientIncidentReport_EnvironmentData_Process_Dll::New() const {
+  return new ClientIncidentReport_EnvironmentData_Process_Dll;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::Clear() {
+  if (_has_bits_[0 / 32] & 23) {
+    if (has_path()) {
+      if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        path_->clear();
+      }
+    }
+    base_address_ = GOOGLE_ULONGLONG(0);
+    length_ = 0u;
+    if (has_image_headers()) {
+      if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+    }
+  }
+  feature_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_Dll::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string path = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_path()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_base_address;
+        break;
+      }
+
+      // optional uint64 base_address = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_base_address:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &base_address_)));
+          set_has_base_address();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_length;
+        break;
+      }
+
+      // optional uint32 length = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_length:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &length_)));
+          set_has_length();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_feature;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.Feature feature = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_feature:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature_IsValid(value)) {
+            add_feature(static_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else if (tag == 34) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(
+                 input,
+                 &::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature_IsValid,
+                 this->mutable_feature())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_feature;
+        if (input->ExpectTag(42)) goto parse_image_headers;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_image_headers:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_image_headers()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+  // optional string path = 1;
+  if (has_path()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->path(), output);
+  }
+
+  // optional uint64 base_address = 2;
+  if (has_base_address()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->base_address(), output);
+  }
+
+  // optional uint32 length = 3;
+  if (has_length()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->length(), output);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.Feature feature = 4;
+  for (int i = 0; i < this->feature_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      4, this->feature(i), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+  if (has_image_headers()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      5, this->image_headers(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+}
+
+int ClientIncidentReport_EnvironmentData_Process_Dll::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string path = 1;
+    if (has_path()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->path());
+    }
+
+    // optional uint64 base_address = 2;
+    if (has_base_address()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->base_address());
+    }
+
+    // optional uint32 length = 3;
+    if (has_length()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->length());
+    }
+
+    // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+    if (has_image_headers()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->image_headers());
+    }
+
+  }
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.Feature feature = 4;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->feature_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
+        this->feature(i));
+    }
+    total_size += 1 * this->feature_size() + data_size;
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_EnvironmentData_Process_Dll*>(&from));
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_Dll& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  feature_.MergeFrom(from.feature_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_path()) {
+      set_path(from.path());
+    }
+    if (from.has_base_address()) {
+      set_base_address(from.base_address());
+    }
+    if (from.has_length()) {
+      set_length(from.length());
+    }
+    if (from.has_image_headers()) {
+      mutable_image_headers()->::safe_browsing::ClientDownloadRequest_ImageHeaders::MergeFrom(from.image_headers());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::CopyFrom(const ClientIncidentReport_EnvironmentData_Process_Dll& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_Dll::IsInitialized() const {
+
+  if (has_image_headers()) {
+    if (!this->image_headers().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_Dll::Swap(ClientIncidentReport_EnvironmentData_Process_Dll* other) {
+  if (other != this) {
+    std::swap(path_, other->path_);
+    std::swap(base_address_, other->base_address_);
+    std::swap(length_, other->length_);
+    feature_.Swap(&other->feature_);
+    std::swap(image_headers_, other->image_headers_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_EnvironmentData_Process_Dll::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll";
+}
+
+
+// -------------------------------------------------------------------
+
+bool ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::UNKNOWN;
+const ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::MODULE_STATE_UNKNOWN;
+const ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::MODULE_STATE_UNMODIFIED;
+const ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::MODULE_STATE_MODIFIED;
+const ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::ModifiedState_MIN;
+const ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState::ModifiedState_MAX;
+const int ClientIncidentReport_EnvironmentData_Process_ModuleState::ModifiedState_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::kFileOffsetFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::kByteCountFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::kModifiedBytesFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::kExportNameFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  file_offset_ = 0u;
+  byte_count_ = 0;
+  modified_bytes_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  export_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+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() {
+  if (modified_bytes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete modified_bytes_;
+  }
+  if (export_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete export_name_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::default_instance_ = NULL;
+
+ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::New() const {
+  return new ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(file_offset_, byte_count_);
+    if (has_modified_bytes()) {
+      if (modified_bytes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        modified_bytes_->clear();
+      }
+    }
+    if (has_export_name()) {
+      if (export_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        export_name_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 file_offset = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &file_offset_)));
+          set_has_file_offset();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_byte_count;
+        break;
+      }
+
+      // optional int32 byte_count = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_byte_count:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &byte_count_)));
+          set_has_byte_count();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_modified_bytes;
+        break;
+      }
+
+      // optional bytes modified_bytes = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_modified_bytes:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_modified_bytes()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_export_name;
+        break;
+      }
+
+      // optional string export_name = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_export_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_export_name()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+  // optional uint32 file_offset = 1;
+  if (has_file_offset()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->file_offset(), output);
+  }
+
+  // optional int32 byte_count = 2;
+  if (has_byte_count()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->byte_count(), output);
+  }
+
+  // optional bytes modified_bytes = 3;
+  if (has_modified_bytes()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->modified_bytes(), output);
+  }
+
+  // optional string export_name = 4;
+  if (has_export_name()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->export_name(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+}
+
+int ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 file_offset = 1;
+    if (has_file_offset()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->file_offset());
+    }
+
+    // optional int32 byte_count = 2;
+    if (has_byte_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->byte_count());
+    }
+
+    // optional bytes modified_bytes = 3;
+    if (has_modified_bytes()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->modified_bytes());
+    }
+
+    // optional string export_name = 4;
+    if (has_export_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->export_name());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification*>(&from));
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_file_offset()) {
+      set_file_offset(from.file_offset());
+    }
+    if (from.has_byte_count()) {
+      set_byte_count(from.byte_count());
+    }
+    if (from.has_modified_bytes()) {
+      set_modified_bytes(from.modified_bytes());
+    }
+    if (from.has_export_name()) {
+      set_export_name(from.export_name());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::CopyFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::Swap(ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* other) {
+  if (other != this) {
+    std::swap(file_offset_, other->file_offset_);
+    std::swap(byte_count_, other->byte_count_);
+    std::swap(modified_bytes_, other->modified_bytes_);
+    std::swap(export_name_, other->export_name_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_EnvironmentData_Process_ModuleState::kNameFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process_ModuleState::kModifiedStateFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process_ModuleState::kOBSOLETEModifiedExportFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process_ModuleState::kModificationFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_EnvironmentData_Process_ModuleState::ClientIncidentReport_EnvironmentData_Process_ModuleState()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_EnvironmentData_Process_ModuleState::ClientIncidentReport_EnvironmentData_Process_ModuleState(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  modified_state_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+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() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_EnvironmentData_Process_ModuleState& ClientIncidentReport_EnvironmentData_Process_ModuleState::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_EnvironmentData_Process_ModuleState* ClientIncidentReport_EnvironmentData_Process_ModuleState::default_instance_ = NULL;
+
+ClientIncidentReport_EnvironmentData_Process_ModuleState* ClientIncidentReport_EnvironmentData_Process_ModuleState::New() const {
+  return new ClientIncidentReport_EnvironmentData_Process_ModuleState;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    modified_state_ = 0;
+  }
+  obsolete_modified_export_.Clear();
+  modification_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_ModuleState::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string name = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_modified_state;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.ModifiedState modified_state = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_modified_state:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_IsValid(value)) {
+            set_modified_state(static_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_OBSOLETE_modified_export;
+        break;
+      }
+
+      // repeated string OBSOLETE_modified_export = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_OBSOLETE_modified_export:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_obsolete_modified_export()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_OBSOLETE_modified_export;
+        if (input->ExpectTag(34)) goto parse_modification;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification modification = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_modification:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_modification()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_modification;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+  // optional string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->name(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.ModifiedState modified_state = 2;
+  if (has_modified_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->modified_state(), output);
+  }
+
+  // repeated string OBSOLETE_modified_export = 3;
+  for (int i = 0; i < this->obsolete_modified_export_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->obsolete_modified_export(i), output);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification modification = 4;
+  for (int i = 0; i < this->modification_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->modification(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+}
+
+int ClientIncidentReport_EnvironmentData_Process_ModuleState::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string name = 1;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.ModifiedState modified_state = 2;
+    if (has_modified_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->modified_state());
+    }
+
+  }
+  // repeated string OBSOLETE_modified_export = 3;
+  total_size += 1 * this->obsolete_modified_export_size();
+  for (int i = 0; i < this->obsolete_modified_export_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->obsolete_modified_export(i));
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification modification = 4;
+  total_size += 1 * this->modification_size();
+  for (int i = 0; i < this->modification_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->modification(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_EnvironmentData_Process_ModuleState*>(&from));
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::MergeFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  obsolete_modified_export_.MergeFrom(from.obsolete_modified_export_);
+  modification_.MergeFrom(from.modification_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_modified_state()) {
+      set_modified_state(from.modified_state());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::CopyFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Process_ModuleState::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Process_ModuleState::Swap(ClientIncidentReport_EnvironmentData_Process_ModuleState* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    std::swap(modified_state_, other->modified_state_);
+    obsolete_modified_export_.Swap(&other->obsolete_modified_export_);
+    modification_.Swap(&other->modification_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_EnvironmentData_Process_ModuleState::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_EnvironmentData_Process::kVersionFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process::kOBSOLETEDllsFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process::kPatchesFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process::kNetworkProvidersFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process::kChromeUpdateChannelFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process::kUptimeMsecFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process::kMetricsConsentFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process::kExtendedConsentFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process::kDllFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process::kBlacklistedDllFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process::kModuleStateFieldNumber;
+const int ClientIncidentReport_EnvironmentData_Process::kFieldTrialParticipantFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_EnvironmentData_Process::ClientIncidentReport_EnvironmentData_Process()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+}
+
+void ClientIncidentReport_EnvironmentData_Process::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_EnvironmentData_Process::ClientIncidentReport_EnvironmentData_Process(const ClientIncidentReport_EnvironmentData_Process& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+}
+
+void ClientIncidentReport_EnvironmentData_Process::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  chrome_update_channel_ = 0;
+  uptime_msec_ = GOOGLE_LONGLONG(0);
+  metrics_consent_ = false;
+  extended_consent_ = false;
+  field_trial_participant_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_EnvironmentData_Process::~ClientIncidentReport_EnvironmentData_Process() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+  SharedDtor();
+}
+
+void ClientIncidentReport_EnvironmentData_Process::SharedDtor() {
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete version_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_EnvironmentData_Process::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_EnvironmentData_Process& ClientIncidentReport_EnvironmentData_Process::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_EnvironmentData_Process* ClientIncidentReport_EnvironmentData_Process::default_instance_ = NULL;
+
+ClientIncidentReport_EnvironmentData_Process* ClientIncidentReport_EnvironmentData_Process::New() const {
+  return new ClientIncidentReport_EnvironmentData_Process;
+}
+
+void ClientIncidentReport_EnvironmentData_Process::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClientIncidentReport_EnvironmentData_Process*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 241) {
+    ZR_(uptime_msec_, extended_consent_);
+    if (has_version()) {
+      if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        version_->clear();
+      }
+    }
+  }
+  field_trial_participant_ = false;
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  obsolete_dlls_.Clear();
+  patches_.Clear();
+  network_providers_.Clear();
+  dll_.Clear();
+  blacklisted_dll_.Clear();
+  module_state_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_EnvironmentData_Process::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string version = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_version()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_OBSOLETE_dlls;
+        break;
+      }
+
+      // repeated string OBSOLETE_dlls = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_OBSOLETE_dlls:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_obsolete_dlls()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_OBSOLETE_dlls;
+        if (input->ExpectTag(26)) goto parse_patches;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch patches = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_patches:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_patches()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_patches;
+        if (input->ExpectTag(34)) goto parse_network_providers;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider network_providers = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_network_providers:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_network_providers()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_network_providers;
+        if (input->ExpectTag(40)) goto parse_chrome_update_channel;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Channel chrome_update_channel = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_chrome_update_channel:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel_IsValid(value)) {
+            set_chrome_update_channel(static_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_uptime_msec;
+        break;
+      }
+
+      // optional int64 uptime_msec = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_uptime_msec:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &uptime_msec_)));
+          set_has_uptime_msec();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_metrics_consent;
+        break;
+      }
+
+      // optional bool metrics_consent = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_metrics_consent:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &metrics_consent_)));
+          set_has_metrics_consent();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_extended_consent;
+        break;
+      }
+
+      // optional bool extended_consent = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_extended_consent:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &extended_consent_)));
+          set_has_extended_consent();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_dll;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll dll = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_dll:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_dll()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_dll;
+        if (input->ExpectTag(82)) goto parse_blacklisted_dll;
+        break;
+      }
+
+      // repeated string blacklisted_dll = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_blacklisted_dll:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_blacklisted_dll()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_blacklisted_dll;
+        if (input->ExpectTag(90)) goto parse_module_state;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState module_state = 11;
+      case 11: {
+        if (tag == 90) {
+         parse_module_state:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_module_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(90)) goto parse_module_state;
+        if (input->ExpectTag(96)) goto parse_field_trial_participant;
+        break;
+      }
+
+      // optional bool field_trial_participant = 12;
+      case 12: {
+        if (tag == 96) {
+         parse_field_trial_participant:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &field_trial_participant_)));
+          set_has_field_trial_participant();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_EnvironmentData_Process::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+  // optional string version = 1;
+  if (has_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->version(), output);
+  }
+
+  // repeated string OBSOLETE_dlls = 2;
+  for (int i = 0; i < this->obsolete_dlls_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->obsolete_dlls(i), output);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch patches = 3;
+  for (int i = 0; i < this->patches_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->patches(i), output);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider network_providers = 4;
+  for (int i = 0; i < this->network_providers_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->network_providers(i), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Channel chrome_update_channel = 5;
+  if (has_chrome_update_channel()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      5, this->chrome_update_channel(), output);
+  }
+
+  // optional int64 uptime_msec = 6;
+  if (has_uptime_msec()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(6, this->uptime_msec(), output);
+  }
+
+  // optional bool metrics_consent = 7;
+  if (has_metrics_consent()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->metrics_consent(), output);
+  }
+
+  // optional bool extended_consent = 8;
+  if (has_extended_consent()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->extended_consent(), output);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll dll = 9;
+  for (int i = 0; i < this->dll_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      9, this->dll(i), output);
+  }
+
+  // repeated string blacklisted_dll = 10;
+  for (int i = 0; i < this->blacklisted_dll_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      10, this->blacklisted_dll(i), output);
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState module_state = 11;
+  for (int i = 0; i < this->module_state_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      11, this->module_state(i), output);
+  }
+
+  // optional bool field_trial_participant = 12;
+  if (has_field_trial_participant()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->field_trial_participant(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+}
+
+int ClientIncidentReport_EnvironmentData_Process::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string version = 1;
+    if (has_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->version());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Channel chrome_update_channel = 5;
+    if (has_chrome_update_channel()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->chrome_update_channel());
+    }
+
+    // optional int64 uptime_msec = 6;
+    if (has_uptime_msec()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->uptime_msec());
+    }
+
+    // optional bool metrics_consent = 7;
+    if (has_metrics_consent()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool extended_consent = 8;
+    if (has_extended_consent()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (_has_bits_[11 / 32] & (0xffu << (11 % 32))) {
+    // optional bool field_trial_participant = 12;
+    if (has_field_trial_participant()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated string OBSOLETE_dlls = 2;
+  total_size += 1 * this->obsolete_dlls_size();
+  for (int i = 0; i < this->obsolete_dlls_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->obsolete_dlls(i));
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch patches = 3;
+  total_size += 1 * this->patches_size();
+  for (int i = 0; i < this->patches_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->patches(i));
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider network_providers = 4;
+  total_size += 1 * this->network_providers_size();
+  for (int i = 0; i < this->network_providers_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->network_providers(i));
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll dll = 9;
+  total_size += 1 * this->dll_size();
+  for (int i = 0; i < this->dll_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->dll(i));
+  }
+
+  // repeated string blacklisted_dll = 10;
+  total_size += 1 * this->blacklisted_dll_size();
+  for (int i = 0; i < this->blacklisted_dll_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->blacklisted_dll(i));
+  }
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState module_state = 11;
+  total_size += 1 * this->module_state_size();
+  for (int i = 0; i < this->module_state_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->module_state(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData_Process::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_EnvironmentData_Process*>(&from));
+}
+
+void ClientIncidentReport_EnvironmentData_Process::MergeFrom(const ClientIncidentReport_EnvironmentData_Process& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  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_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_version()) {
+      set_version(from.version());
+    }
+    if (from.has_chrome_update_channel()) {
+      set_chrome_update_channel(from.chrome_update_channel());
+    }
+    if (from.has_uptime_msec()) {
+      set_uptime_msec(from.uptime_msec());
+    }
+    if (from.has_metrics_consent()) {
+      set_metrics_consent(from.metrics_consent());
+    }
+    if (from.has_extended_consent()) {
+      set_extended_consent(from.extended_consent());
+    }
+  }
+  if (from._has_bits_[11 / 32] & (0xffu << (11 % 32))) {
+    if (from.has_field_trial_participant()) {
+      set_field_trial_participant(from.field_trial_participant());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_EnvironmentData_Process::CopyFrom(const ClientIncidentReport_EnvironmentData_Process& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData_Process::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->dll())) return false;
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData_Process::Swap(ClientIncidentReport_EnvironmentData_Process* other) {
+  if (other != this) {
+    std::swap(version_, other->version_);
+    obsolete_dlls_.Swap(&other->obsolete_dlls_);
+    patches_.Swap(&other->patches_);
+    network_providers_.Swap(&other->network_providers_);
+    std::swap(chrome_update_channel_, other->chrome_update_channel_);
+    std::swap(uptime_msec_, other->uptime_msec_);
+    std::swap(metrics_consent_, other->metrics_consent_);
+    std::swap(extended_consent_, other->extended_consent_);
+    dll_.Swap(&other->dll_);
+    blacklisted_dll_.Swap(&other->blacklisted_dll_);
+    module_state_.Swap(&other->module_state_);
+    std::swap(field_trial_participant_, other->field_trial_participant_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_EnvironmentData_Process::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData.Process";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_EnvironmentData::kOsFieldNumber;
+const int ClientIncidentReport_EnvironmentData::kMachineFieldNumber;
+const int ClientIncidentReport_EnvironmentData::kProcessFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_EnvironmentData::ClientIncidentReport_EnvironmentData()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.EnvironmentData)
+}
+
+void ClientIncidentReport_EnvironmentData::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  os_ = const_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS*>(
+      ::safe_browsing::ClientIncidentReport_EnvironmentData_OS::internal_default_instance());
+#else
+  os_ = const_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS*>(&::safe_browsing::ClientIncidentReport_EnvironmentData_OS::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  machine_ = const_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine*>(
+      ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine::internal_default_instance());
+#else
+  machine_ = const_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine*>(&::safe_browsing::ClientIncidentReport_EnvironmentData_Machine::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  process_ = const_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process*>(
+      ::safe_browsing::ClientIncidentReport_EnvironmentData_Process::internal_default_instance());
+#else
+  process_ = const_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process*>(&::safe_browsing::ClientIncidentReport_EnvironmentData_Process::default_instance());
+#endif
+}
+
+ClientIncidentReport_EnvironmentData::ClientIncidentReport_EnvironmentData(const ClientIncidentReport_EnvironmentData& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.EnvironmentData)
+}
+
+void ClientIncidentReport_EnvironmentData::SharedCtor() {
+  _cached_size_ = 0;
+  os_ = NULL;
+  machine_ = NULL;
+  process_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_EnvironmentData::~ClientIncidentReport_EnvironmentData() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.EnvironmentData)
+  SharedDtor();
+}
+
+void ClientIncidentReport_EnvironmentData::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete os_;
+    delete machine_;
+    delete process_;
+  }
+}
+
+void ClientIncidentReport_EnvironmentData::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_EnvironmentData& ClientIncidentReport_EnvironmentData::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_EnvironmentData* ClientIncidentReport_EnvironmentData::default_instance_ = NULL;
+
+ClientIncidentReport_EnvironmentData* ClientIncidentReport_EnvironmentData::New() const {
+  return new ClientIncidentReport_EnvironmentData;
+}
+
+void ClientIncidentReport_EnvironmentData::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_os()) {
+      if (os_ != NULL) os_->::safe_browsing::ClientIncidentReport_EnvironmentData_OS::Clear();
+    }
+    if (has_machine()) {
+      if (machine_ != NULL) machine_->::safe_browsing::ClientIncidentReport_EnvironmentData_Machine::Clear();
+    }
+    if (has_process()) {
+      if (process_ != NULL) process_->::safe_browsing::ClientIncidentReport_EnvironmentData_Process::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_EnvironmentData::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.EnvironmentData)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .safe_browsing.ClientIncidentReport.EnvironmentData.OS os = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_os()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_machine;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Machine machine = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_machine:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_machine()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_process;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process process = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_process:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_process()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.EnvironmentData)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.EnvironmentData)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_EnvironmentData::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.EnvironmentData)
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.OS os = 1;
+  if (has_os()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->os(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Machine machine = 2;
+  if (has_machine()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->machine(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process process = 3;
+  if (has_process()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->process(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.EnvironmentData)
+}
+
+int ClientIncidentReport_EnvironmentData::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .safe_browsing.ClientIncidentReport.EnvironmentData.OS os = 1;
+    if (has_os()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->os());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Machine machine = 2;
+    if (has_machine()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->machine());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process process = 3;
+    if (has_process()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->process());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_EnvironmentData::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_EnvironmentData*>(&from));
+}
+
+void ClientIncidentReport_EnvironmentData::MergeFrom(const ClientIncidentReport_EnvironmentData& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_os()) {
+      mutable_os()->::safe_browsing::ClientIncidentReport_EnvironmentData_OS::MergeFrom(from.os());
+    }
+    if (from.has_machine()) {
+      mutable_machine()->::safe_browsing::ClientIncidentReport_EnvironmentData_Machine::MergeFrom(from.machine());
+    }
+    if (from.has_process()) {
+      mutable_process()->::safe_browsing::ClientIncidentReport_EnvironmentData_Process::MergeFrom(from.process());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_EnvironmentData::CopyFrom(const ClientIncidentReport_EnvironmentData& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_EnvironmentData::IsInitialized() const {
+
+  if (has_process()) {
+    if (!this->process().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport_EnvironmentData::Swap(ClientIncidentReport_EnvironmentData* other) {
+  if (other != this) {
+    std::swap(os_, other->os_);
+    std::swap(machine_, other->machine_);
+    std::swap(process_, other->process_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_EnvironmentData::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.EnvironmentData";
+}
+
+
+// -------------------------------------------------------------------
+
+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;
+  }
+}
+
+#ifndef _MSC_VER
+const ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::STATE_UNKNOWN;
+const ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::STATE_ENABLED;
+const ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::STATE_DISABLED;
+const ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::STATE_BLACKLISTED;
+const ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::STATE_BLOCKED;
+const ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::STATE_TERMINATED;
+const ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::ExtensionState_MIN;
+const ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo::ExtensionState_MAX;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::ExtensionState_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kIdFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kVersionFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kNameFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kDescriptionFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kStateFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kTypeFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kUpdateUrlFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kHasSignatureValidationFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kSignatureIsValidFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kInstalledByCustodianFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kInstalledByDefaultFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kInstalledByOemFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kFromBookmarkFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kFromWebstoreFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kConvertedFromUserScriptFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kMayBeUntrustedFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kInstallTimeMsecFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kManifestLocationTypeFieldNumber;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo::kManifestFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_ExtensionData_ExtensionInfo::ClientIncidentReport_ExtensionData_ExtensionInfo()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_ExtensionData_ExtensionInfo::ClientIncidentReport_ExtensionData_ExtensionInfo(const ClientIncidentReport_ExtensionData_ExtensionInfo& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  state_ = 0;
+  type_ = 0;
+  update_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  has_signature_validation_ = false;
+  signature_is_valid_ = false;
+  installed_by_custodian_ = false;
+  installed_by_default_ = false;
+  installed_by_oem_ = false;
+  from_bookmark_ = false;
+  from_webstore_ = false;
+  converted_from_user_script_ = false;
+  may_be_untrusted_ = false;
+  install_time_msec_ = GOOGLE_LONGLONG(0);
+  manifest_location_type_ = 0;
+  manifest_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_ExtensionData_ExtensionInfo::~ClientIncidentReport_ExtensionData_ExtensionInfo() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+  SharedDtor();
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::SharedDtor() {
+  if (id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete id_;
+  }
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete version_;
+  }
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (update_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete update_url_;
+  }
+  if (manifest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete manifest_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_ExtensionData_ExtensionInfo& ClientIncidentReport_ExtensionData_ExtensionInfo::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_ExtensionData_ExtensionInfo* ClientIncidentReport_ExtensionData_ExtensionInfo::default_instance_ = NULL;
+
+ClientIncidentReport_ExtensionData_ExtensionInfo* ClientIncidentReport_ExtensionData_ExtensionInfo::New() const {
+  return new ClientIncidentReport_ExtensionData_ExtensionInfo;
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClientIncidentReport_ExtensionData_ExtensionInfo*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(state_, type_);
+    if (has_id()) {
+      if (id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        id_->clear();
+      }
+    }
+    if (has_version()) {
+      if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        version_->clear();
+      }
+    }
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    if (has_description()) {
+      if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        description_->clear();
+      }
+    }
+    if (has_update_url()) {
+      if (update_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        update_url_->clear();
+      }
+    }
+    has_signature_validation_ = false;
+  }
+  if (_has_bits_[8 / 32] & 65280) {
+    ZR_(signature_is_valid_, converted_from_user_script_);
+    may_be_untrusted_ = false;
+  }
+  if (_has_bits_[16 / 32] & 458752) {
+    install_time_msec_ = GOOGLE_LONGLONG(0);
+    manifest_location_type_ = 0;
+    if (has_manifest()) {
+      if (manifest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        manifest_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_ExtensionData_ExtensionInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_version;
+        break;
+      }
+
+      // optional string version = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_version:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_version()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_description;
+        break;
+      }
+
+      // optional string description = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_description:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_description()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_state;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.ExtensionState state = 5 [default = STATE_UNKNOWN];
+      case 5: {
+        if (tag == 40) {
+         parse_state:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_IsValid(value)) {
+            set_state(static_cast< ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_type;
+        break;
+      }
+
+      // optional int32 type = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_type:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &type_)));
+          set_has_type();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_update_url;
+        break;
+      }
+
+      // optional string update_url = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_update_url:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_update_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_has_signature_validation;
+        break;
+      }
+
+      // optional bool has_signature_validation = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_has_signature_validation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &has_signature_validation_)));
+          set_has_has_signature_validation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(72)) goto parse_signature_is_valid;
+        break;
+      }
+
+      // optional bool signature_is_valid = 9;
+      case 9: {
+        if (tag == 72) {
+         parse_signature_is_valid:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &signature_is_valid_)));
+          set_has_signature_is_valid();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(80)) goto parse_installed_by_custodian;
+        break;
+      }
+
+      // optional bool installed_by_custodian = 10;
+      case 10: {
+        if (tag == 80) {
+         parse_installed_by_custodian:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &installed_by_custodian_)));
+          set_has_installed_by_custodian();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(88)) goto parse_installed_by_default;
+        break;
+      }
+
+      // optional bool installed_by_default = 11;
+      case 11: {
+        if (tag == 88) {
+         parse_installed_by_default:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &installed_by_default_)));
+          set_has_installed_by_default();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(96)) goto parse_installed_by_oem;
+        break;
+      }
+
+      // optional bool installed_by_oem = 12;
+      case 12: {
+        if (tag == 96) {
+         parse_installed_by_oem:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &installed_by_oem_)));
+          set_has_installed_by_oem();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(104)) goto parse_from_bookmark;
+        break;
+      }
+
+      // optional bool from_bookmark = 13;
+      case 13: {
+        if (tag == 104) {
+         parse_from_bookmark:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &from_bookmark_)));
+          set_has_from_bookmark();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(112)) goto parse_from_webstore;
+        break;
+      }
+
+      // optional bool from_webstore = 14;
+      case 14: {
+        if (tag == 112) {
+         parse_from_webstore:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &from_webstore_)));
+          set_has_from_webstore();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(120)) goto parse_converted_from_user_script;
+        break;
+      }
+
+      // optional bool converted_from_user_script = 15;
+      case 15: {
+        if (tag == 120) {
+         parse_converted_from_user_script:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &converted_from_user_script_)));
+          set_has_converted_from_user_script();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(128)) goto parse_may_be_untrusted;
+        break;
+      }
+
+      // optional bool may_be_untrusted = 16;
+      case 16: {
+        if (tag == 128) {
+         parse_may_be_untrusted:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &may_be_untrusted_)));
+          set_has_may_be_untrusted();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(136)) goto parse_install_time_msec;
+        break;
+      }
+
+      // optional int64 install_time_msec = 17;
+      case 17: {
+        if (tag == 136) {
+         parse_install_time_msec:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &install_time_msec_)));
+          set_has_install_time_msec();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(144)) goto parse_manifest_location_type;
+        break;
+      }
+
+      // optional int32 manifest_location_type = 18;
+      case 18: {
+        if (tag == 144) {
+         parse_manifest_location_type:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &manifest_location_type_)));
+          set_has_manifest_location_type();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(154)) goto parse_manifest;
+        break;
+      }
+
+      // optional string manifest = 19;
+      case 19: {
+        if (tag == 154) {
+         parse_manifest:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_manifest()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+  // optional string id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->id(), output);
+  }
+
+  // optional string version = 2;
+  if (has_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->version(), output);
+  }
+
+  // optional string name = 3;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->name(), output);
+  }
+
+  // optional string description = 4;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->description(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.ExtensionState state = 5 [default = STATE_UNKNOWN];
+  if (has_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      5, this->state(), output);
+  }
+
+  // optional int32 type = 6;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->type(), output);
+  }
+
+  // optional string update_url = 7;
+  if (has_update_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      7, this->update_url(), output);
+  }
+
+  // optional bool has_signature_validation = 8;
+  if (has_has_signature_validation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->has_signature_validation(), output);
+  }
+
+  // optional bool signature_is_valid = 9;
+  if (has_signature_is_valid()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->signature_is_valid(), output);
+  }
+
+  // optional bool installed_by_custodian = 10;
+  if (has_installed_by_custodian()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->installed_by_custodian(), output);
+  }
+
+  // optional bool installed_by_default = 11;
+  if (has_installed_by_default()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->installed_by_default(), output);
+  }
+
+  // optional bool installed_by_oem = 12;
+  if (has_installed_by_oem()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->installed_by_oem(), output);
+  }
+
+  // optional bool from_bookmark = 13;
+  if (has_from_bookmark()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(13, this->from_bookmark(), output);
+  }
+
+  // optional bool from_webstore = 14;
+  if (has_from_webstore()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(14, this->from_webstore(), output);
+  }
+
+  // optional bool converted_from_user_script = 15;
+  if (has_converted_from_user_script()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(15, this->converted_from_user_script(), output);
+  }
+
+  // optional bool may_be_untrusted = 16;
+  if (has_may_be_untrusted()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(16, this->may_be_untrusted(), output);
+  }
+
+  // optional int64 install_time_msec = 17;
+  if (has_install_time_msec()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(17, this->install_time_msec(), output);
+  }
+
+  // optional int32 manifest_location_type = 18;
+  if (has_manifest_location_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(18, this->manifest_location_type(), output);
+  }
+
+  // optional string manifest = 19;
+  if (has_manifest()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      19, this->manifest(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+}
+
+int ClientIncidentReport_ExtensionData_ExtensionInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->id());
+    }
+
+    // optional string version = 2;
+    if (has_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->version());
+    }
+
+    // optional string name = 3;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional string description = 4;
+    if (has_description()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->description());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.ExtensionState state = 5 [default = STATE_UNKNOWN];
+    if (has_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->state());
+    }
+
+    // optional int32 type = 6;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->type());
+    }
+
+    // optional string update_url = 7;
+    if (has_update_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->update_url());
+    }
+
+    // optional bool has_signature_validation = 8;
+    if (has_has_signature_validation()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional bool signature_is_valid = 9;
+    if (has_signature_is_valid()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool installed_by_custodian = 10;
+    if (has_installed_by_custodian()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool installed_by_default = 11;
+    if (has_installed_by_default()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool installed_by_oem = 12;
+    if (has_installed_by_oem()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool from_bookmark = 13;
+    if (has_from_bookmark()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool from_webstore = 14;
+    if (has_from_webstore()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool converted_from_user_script = 15;
+    if (has_converted_from_user_script()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool may_be_untrusted = 16;
+    if (has_may_be_untrusted()) {
+      total_size += 2 + 1;
+    }
+
+  }
+  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    // optional int64 install_time_msec = 17;
+    if (has_install_time_msec()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->install_time_msec());
+    }
+
+    // optional int32 manifest_location_type = 18;
+    if (has_manifest_location_type()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->manifest_location_type());
+    }
+
+    // optional string manifest = 19;
+    if (has_manifest()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->manifest());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_ExtensionData_ExtensionInfo*>(&from));
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::MergeFrom(const ClientIncidentReport_ExtensionData_ExtensionInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_version()) {
+      set_version(from.version());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_description()) {
+      set_description(from.description());
+    }
+    if (from.has_state()) {
+      set_state(from.state());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_update_url()) {
+      set_update_url(from.update_url());
+    }
+    if (from.has_has_signature_validation()) {
+      set_has_signature_validation(from.has_signature_validation());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_signature_is_valid()) {
+      set_signature_is_valid(from.signature_is_valid());
+    }
+    if (from.has_installed_by_custodian()) {
+      set_installed_by_custodian(from.installed_by_custodian());
+    }
+    if (from.has_installed_by_default()) {
+      set_installed_by_default(from.installed_by_default());
+    }
+    if (from.has_installed_by_oem()) {
+      set_installed_by_oem(from.installed_by_oem());
+    }
+    if (from.has_from_bookmark()) {
+      set_from_bookmark(from.from_bookmark());
+    }
+    if (from.has_from_webstore()) {
+      set_from_webstore(from.from_webstore());
+    }
+    if (from.has_converted_from_user_script()) {
+      set_converted_from_user_script(from.converted_from_user_script());
+    }
+    if (from.has_may_be_untrusted()) {
+      set_may_be_untrusted(from.may_be_untrusted());
+    }
+  }
+  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    if (from.has_install_time_msec()) {
+      set_install_time_msec(from.install_time_msec());
+    }
+    if (from.has_manifest_location_type()) {
+      set_manifest_location_type(from.manifest_location_type());
+    }
+    if (from.has_manifest()) {
+      set_manifest(from.manifest());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::CopyFrom(const ClientIncidentReport_ExtensionData_ExtensionInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_ExtensionData_ExtensionInfo::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_ExtensionData_ExtensionInfo::Swap(ClientIncidentReport_ExtensionData_ExtensionInfo* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(version_, other->version_);
+    std::swap(name_, other->name_);
+    std::swap(description_, other->description_);
+    std::swap(state_, other->state_);
+    std::swap(type_, other->type_);
+    std::swap(update_url_, other->update_url_);
+    std::swap(has_signature_validation_, other->has_signature_validation_);
+    std::swap(signature_is_valid_, other->signature_is_valid_);
+    std::swap(installed_by_custodian_, other->installed_by_custodian_);
+    std::swap(installed_by_default_, other->installed_by_default_);
+    std::swap(installed_by_oem_, other->installed_by_oem_);
+    std::swap(from_bookmark_, other->from_bookmark_);
+    std::swap(from_webstore_, other->from_webstore_);
+    std::swap(converted_from_user_script_, other->converted_from_user_script_);
+    std::swap(may_be_untrusted_, other->may_be_untrusted_);
+    std::swap(install_time_msec_, other->install_time_msec_);
+    std::swap(manifest_location_type_, other->manifest_location_type_);
+    std::swap(manifest_, other->manifest_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_ExtensionData_ExtensionInfo::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_ExtensionData::kLastInstalledExtensionFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_ExtensionData::ClientIncidentReport_ExtensionData()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.ExtensionData)
+}
+
+void ClientIncidentReport_ExtensionData::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  last_installed_extension_ = const_cast< ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo*>(
+      ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo::internal_default_instance());
+#else
+  last_installed_extension_ = const_cast< ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo*>(&::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo::default_instance());
+#endif
+}
+
+ClientIncidentReport_ExtensionData::ClientIncidentReport_ExtensionData(const ClientIncidentReport_ExtensionData& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.ExtensionData)
+}
+
+void ClientIncidentReport_ExtensionData::SharedCtor() {
+  _cached_size_ = 0;
+  last_installed_extension_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_ExtensionData::~ClientIncidentReport_ExtensionData() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.ExtensionData)
+  SharedDtor();
+}
+
+void ClientIncidentReport_ExtensionData::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete last_installed_extension_;
+  }
+}
+
+void ClientIncidentReport_ExtensionData::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_ExtensionData& ClientIncidentReport_ExtensionData::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_ExtensionData* ClientIncidentReport_ExtensionData::default_instance_ = NULL;
+
+ClientIncidentReport_ExtensionData* ClientIncidentReport_ExtensionData::New() const {
+  return new ClientIncidentReport_ExtensionData;
+}
+
+void ClientIncidentReport_ExtensionData::Clear() {
+  if (has_last_installed_extension()) {
+    if (last_installed_extension_ != NULL) last_installed_extension_->::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_ExtensionData::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.ExtensionData)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo last_installed_extension = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_last_installed_extension()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.ExtensionData)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.ExtensionData)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_ExtensionData::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.ExtensionData)
+  // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo last_installed_extension = 1;
+  if (has_last_installed_extension()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->last_installed_extension(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.ExtensionData)
+}
+
+int ClientIncidentReport_ExtensionData::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo last_installed_extension = 1;
+    if (has_last_installed_extension()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->last_installed_extension());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_ExtensionData::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_ExtensionData*>(&from));
+}
+
+void ClientIncidentReport_ExtensionData::MergeFrom(const ClientIncidentReport_ExtensionData& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_last_installed_extension()) {
+      mutable_last_installed_extension()->::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo::MergeFrom(from.last_installed_extension());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_ExtensionData::CopyFrom(const ClientIncidentReport_ExtensionData& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_ExtensionData::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_ExtensionData::Swap(ClientIncidentReport_ExtensionData* other) {
+  if (other != this) {
+    std::swap(last_installed_extension_, other->last_installed_extension_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_ExtensionData::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.ExtensionData";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport_NonBinaryDownloadDetails::kFileTypeFieldNumber;
+const int ClientIncidentReport_NonBinaryDownloadDetails::kUrlSpecSha256FieldNumber;
+const int ClientIncidentReport_NonBinaryDownloadDetails::kHostFieldNumber;
+const int ClientIncidentReport_NonBinaryDownloadDetails::kLengthFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport_NonBinaryDownloadDetails::ClientIncidentReport_NonBinaryDownloadDetails()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::InitAsDefaultInstance() {
+}
+
+ClientIncidentReport_NonBinaryDownloadDetails::ClientIncidentReport_NonBinaryDownloadDetails(const ClientIncidentReport_NonBinaryDownloadDetails& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  file_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  url_spec_sha256_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  host_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  length_ = GOOGLE_LONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport_NonBinaryDownloadDetails::~ClientIncidentReport_NonBinaryDownloadDetails() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+  SharedDtor();
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::SharedDtor() {
+  if (file_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete file_type_;
+  }
+  if (url_spec_sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_spec_sha256_;
+  }
+  if (host_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete host_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport_NonBinaryDownloadDetails& ClientIncidentReport_NonBinaryDownloadDetails::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport_NonBinaryDownloadDetails* ClientIncidentReport_NonBinaryDownloadDetails::default_instance_ = NULL;
+
+ClientIncidentReport_NonBinaryDownloadDetails* ClientIncidentReport_NonBinaryDownloadDetails::New() const {
+  return new ClientIncidentReport_NonBinaryDownloadDetails;
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_file_type()) {
+      if (file_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        file_type_->clear();
+      }
+    }
+    if (has_url_spec_sha256()) {
+      if (url_spec_sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_spec_sha256_->clear();
+      }
+    }
+    if (has_host()) {
+      if (host_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        host_->clear();
+      }
+    }
+    length_ = GOOGLE_LONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport_NonBinaryDownloadDetails::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string file_type = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_file_type()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_url_spec_sha256;
+        break;
+      }
+
+      // optional bytes url_spec_sha256 = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_url_spec_sha256:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_url_spec_sha256()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_host;
+        break;
+      }
+
+      // optional string host = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_host:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_host()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_length;
+        break;
+      }
+
+      // optional int64 length = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_length:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &length_)));
+          set_has_length();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+  // optional string file_type = 1;
+  if (has_file_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->file_type(), output);
+  }
+
+  // optional bytes url_spec_sha256 = 2;
+  if (has_url_spec_sha256()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->url_spec_sha256(), output);
+  }
+
+  // optional string host = 3;
+  if (has_host()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->host(), output);
+  }
+
+  // optional int64 length = 4;
+  if (has_length()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(4, this->length(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+}
+
+int ClientIncidentReport_NonBinaryDownloadDetails::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string file_type = 1;
+    if (has_file_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->file_type());
+    }
+
+    // optional bytes url_spec_sha256 = 2;
+    if (has_url_spec_sha256()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->url_spec_sha256());
+    }
+
+    // optional string host = 3;
+    if (has_host()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->host());
+    }
+
+    // optional int64 length = 4;
+    if (has_length()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->length());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport_NonBinaryDownloadDetails*>(&from));
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::MergeFrom(const ClientIncidentReport_NonBinaryDownloadDetails& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_file_type()) {
+      set_file_type(from.file_type());
+    }
+    if (from.has_url_spec_sha256()) {
+      set_url_spec_sha256(from.url_spec_sha256());
+    }
+    if (from.has_host()) {
+      set_host(from.host());
+    }
+    if (from.has_length()) {
+      set_length(from.length());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::CopyFrom(const ClientIncidentReport_NonBinaryDownloadDetails& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport_NonBinaryDownloadDetails::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentReport_NonBinaryDownloadDetails::Swap(ClientIncidentReport_NonBinaryDownloadDetails* other) {
+  if (other != this) {
+    std::swap(file_type_, other->file_type_);
+    std::swap(url_spec_sha256_, other->url_spec_sha256_);
+    std::swap(host_, other->host_);
+    std::swap(length_, other->length_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport_NonBinaryDownloadDetails::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentReport::kIncidentFieldNumber;
+const int ClientIncidentReport::kDownloadFieldNumber;
+const int ClientIncidentReport::kEnvironmentFieldNumber;
+const int ClientIncidentReport::kPopulationFieldNumber;
+const int ClientIncidentReport::kExtensionDataFieldNumber;
+const int ClientIncidentReport::kNonBinaryDownloadFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentReport::ClientIncidentReport()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentReport)
+}
+
+void ClientIncidentReport::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  download_ = const_cast< ::safe_browsing::ClientIncidentReport_DownloadDetails*>(
+      ::safe_browsing::ClientIncidentReport_DownloadDetails::internal_default_instance());
+#else
+  download_ = const_cast< ::safe_browsing::ClientIncidentReport_DownloadDetails*>(&::safe_browsing::ClientIncidentReport_DownloadDetails::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  environment_ = const_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData*>(
+      ::safe_browsing::ClientIncidentReport_EnvironmentData::internal_default_instance());
+#else
+  environment_ = const_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData*>(&::safe_browsing::ClientIncidentReport_EnvironmentData::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  population_ = const_cast< ::safe_browsing::ChromeUserPopulation*>(
+      ::safe_browsing::ChromeUserPopulation::internal_default_instance());
+#else
+  population_ = const_cast< ::safe_browsing::ChromeUserPopulation*>(&::safe_browsing::ChromeUserPopulation::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  extension_data_ = const_cast< ::safe_browsing::ClientIncidentReport_ExtensionData*>(
+      ::safe_browsing::ClientIncidentReport_ExtensionData::internal_default_instance());
+#else
+  extension_data_ = const_cast< ::safe_browsing::ClientIncidentReport_ExtensionData*>(&::safe_browsing::ClientIncidentReport_ExtensionData::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  non_binary_download_ = const_cast< ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails*>(
+      ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails::internal_default_instance());
+#else
+  non_binary_download_ = const_cast< ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails*>(&::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails::default_instance());
+#endif
+}
+
+ClientIncidentReport::ClientIncidentReport(const ClientIncidentReport& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentReport)
+}
+
+void ClientIncidentReport::SharedCtor() {
+  _cached_size_ = 0;
+  download_ = NULL;
+  environment_ = NULL;
+  population_ = NULL;
+  extension_data_ = NULL;
+  non_binary_download_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentReport::~ClientIncidentReport() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentReport)
+  SharedDtor();
+}
+
+void ClientIncidentReport::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete download_;
+    delete environment_;
+    delete population_;
+    delete extension_data_;
+    delete non_binary_download_;
+  }
+}
+
+void ClientIncidentReport::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentReport& ClientIncidentReport::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentReport* ClientIncidentReport::default_instance_ = NULL;
+
+ClientIncidentReport* ClientIncidentReport::New() const {
+  return new ClientIncidentReport;
+}
+
+void ClientIncidentReport::Clear() {
+  if (_has_bits_[0 / 32] & 62) {
+    if (has_download()) {
+      if (download_ != NULL) download_->::safe_browsing::ClientIncidentReport_DownloadDetails::Clear();
+    }
+    if (has_environment()) {
+      if (environment_ != NULL) environment_->::safe_browsing::ClientIncidentReport_EnvironmentData::Clear();
+    }
+    if (has_population()) {
+      if (population_ != NULL) population_->::safe_browsing::ChromeUserPopulation::Clear();
+    }
+    if (has_extension_data()) {
+      if (extension_data_ != NULL) extension_data_->::safe_browsing::ClientIncidentReport_ExtensionData::Clear();
+    }
+    if (has_non_binary_download()) {
+      if (non_binary_download_ != NULL) non_binary_download_->::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails::Clear();
+    }
+  }
+  incident_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentReport::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentReport)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .safe_browsing.ClientIncidentReport.IncidentData incident = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_incident:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_incident()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_incident;
+        if (input->ExpectTag(18)) goto parse_download;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_download:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_download()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_environment;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.EnvironmentData environment = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_environment:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_environment()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_population;
+        break;
+      }
+
+      // optional .safe_browsing.ChromeUserPopulation population = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_population:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_population()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_extension_data;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.ExtensionData extension_data = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_extension_data:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_extension_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_non_binary_download;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails non_binary_download = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_non_binary_download:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_non_binary_download()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentReport)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentReport)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentReport::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentReport)
+  // repeated .safe_browsing.ClientIncidentReport.IncidentData incident = 1;
+  for (int i = 0; i < this->incident_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->incident(i), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+  if (has_download()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->download(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData environment = 3;
+  if (has_environment()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->environment(), output);
+  }
+
+  // optional .safe_browsing.ChromeUserPopulation population = 7;
+  if (has_population()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      7, this->population(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.ExtensionData extension_data = 8;
+  if (has_extension_data()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      8, this->extension_data(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails non_binary_download = 9;
+  if (has_non_binary_download()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      9, this->non_binary_download(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentReport)
+}
+
+int ClientIncidentReport::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+    if (has_download()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->download());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.EnvironmentData environment = 3;
+    if (has_environment()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->environment());
+    }
+
+    // optional .safe_browsing.ChromeUserPopulation population = 7;
+    if (has_population()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->population());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.ExtensionData extension_data = 8;
+    if (has_extension_data()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->extension_data());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails non_binary_download = 9;
+    if (has_non_binary_download()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->non_binary_download());
+    }
+
+  }
+  // repeated .safe_browsing.ClientIncidentReport.IncidentData incident = 1;
+  total_size += 1 * this->incident_size();
+  for (int i = 0; i < this->incident_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->incident(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentReport::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentReport*>(&from));
+}
+
+void ClientIncidentReport::MergeFrom(const ClientIncidentReport& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  incident_.MergeFrom(from.incident_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_download()) {
+      mutable_download()->::safe_browsing::ClientIncidentReport_DownloadDetails::MergeFrom(from.download());
+    }
+    if (from.has_environment()) {
+      mutable_environment()->::safe_browsing::ClientIncidentReport_EnvironmentData::MergeFrom(from.environment());
+    }
+    if (from.has_population()) {
+      mutable_population()->::safe_browsing::ChromeUserPopulation::MergeFrom(from.population());
+    }
+    if (from.has_extension_data()) {
+      mutable_extension_data()->::safe_browsing::ClientIncidentReport_ExtensionData::MergeFrom(from.extension_data());
+    }
+    if (from.has_non_binary_download()) {
+      mutable_non_binary_download()->::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails::MergeFrom(from.non_binary_download());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentReport::CopyFrom(const ClientIncidentReport& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentReport::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->incident())) return false;
+  if (has_download()) {
+    if (!this->download().IsInitialized()) return false;
+  }
+  if (has_environment()) {
+    if (!this->environment().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientIncidentReport::Swap(ClientIncidentReport* other) {
+  if (other != this) {
+    incident_.Swap(&other->incident_);
+    std::swap(download_, other->download_);
+    std::swap(environment_, other->environment_);
+    std::swap(population_, other->population_);
+    std::swap(extension_data_, other->extension_data_);
+    std::swap(non_binary_download_, other->non_binary_download_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentReport::GetTypeName() const {
+  return "safe_browsing.ClientIncidentReport";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClientIncidentResponse_EnvironmentRequest::kDllIndexFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentResponse_EnvironmentRequest::ClientIncidentResponse_EnvironmentRequest()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+}
+
+void ClientIncidentResponse_EnvironmentRequest::InitAsDefaultInstance() {
+}
+
+ClientIncidentResponse_EnvironmentRequest::ClientIncidentResponse_EnvironmentRequest(const ClientIncidentResponse_EnvironmentRequest& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+}
+
+void ClientIncidentResponse_EnvironmentRequest::SharedCtor() {
+  _cached_size_ = 0;
+  dll_index_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentResponse_EnvironmentRequest::~ClientIncidentResponse_EnvironmentRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+  SharedDtor();
+}
+
+void ClientIncidentResponse_EnvironmentRequest::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentResponse_EnvironmentRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentResponse_EnvironmentRequest& ClientIncidentResponse_EnvironmentRequest::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentResponse_EnvironmentRequest* ClientIncidentResponse_EnvironmentRequest::default_instance_ = NULL;
+
+ClientIncidentResponse_EnvironmentRequest* ClientIncidentResponse_EnvironmentRequest::New() const {
+  return new ClientIncidentResponse_EnvironmentRequest;
+}
+
+void ClientIncidentResponse_EnvironmentRequest::Clear() {
+  dll_index_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentResponse_EnvironmentRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional int32 dll_index = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &dll_index_)));
+          set_has_dll_index();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentResponse_EnvironmentRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+  // optional int32 dll_index = 1;
+  if (has_dll_index()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->dll_index(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+}
+
+int ClientIncidentResponse_EnvironmentRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional int32 dll_index = 1;
+    if (has_dll_index()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->dll_index());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentResponse_EnvironmentRequest::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentResponse_EnvironmentRequest*>(&from));
+}
+
+void ClientIncidentResponse_EnvironmentRequest::MergeFrom(const ClientIncidentResponse_EnvironmentRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_dll_index()) {
+      set_dll_index(from.dll_index());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentResponse_EnvironmentRequest::CopyFrom(const ClientIncidentResponse_EnvironmentRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentResponse_EnvironmentRequest::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentResponse_EnvironmentRequest::Swap(ClientIncidentResponse_EnvironmentRequest* other) {
+  if (other != this) {
+    std::swap(dll_index_, other->dll_index_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentResponse_EnvironmentRequest::GetTypeName() const {
+  return "safe_browsing.ClientIncidentResponse.EnvironmentRequest";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientIncidentResponse::kTokenFieldNumber;
+const int ClientIncidentResponse::kDownloadRequestedFieldNumber;
+const int ClientIncidentResponse::kEnvironmentRequestsFieldNumber;
+#endif  // !_MSC_VER
+
+ClientIncidentResponse::ClientIncidentResponse()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientIncidentResponse)
+}
+
+void ClientIncidentResponse::InitAsDefaultInstance() {
+}
+
+ClientIncidentResponse::ClientIncidentResponse(const ClientIncidentResponse& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientIncidentResponse)
+}
+
+void ClientIncidentResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  download_requested_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientIncidentResponse::~ClientIncidentResponse() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientIncidentResponse)
+  SharedDtor();
+}
+
+void ClientIncidentResponse::SharedDtor() {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete token_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientIncidentResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientIncidentResponse& ClientIncidentResponse::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientIncidentResponse* ClientIncidentResponse::default_instance_ = NULL;
+
+ClientIncidentResponse* ClientIncidentResponse::New() const {
+  return new ClientIncidentResponse;
+}
+
+void ClientIncidentResponse::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_token()) {
+      if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        token_->clear();
+      }
+    }
+    download_requested_ = false;
+  }
+  environment_requests_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientIncidentResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientIncidentResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes token = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_token()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_download_requested;
+        break;
+      }
+
+      // optional bool download_requested = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_download_requested:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &download_requested_)));
+          set_has_download_requested();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_environment_requests;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientIncidentResponse.EnvironmentRequest environment_requests = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_environment_requests:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_environment_requests()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_environment_requests;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientIncidentResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientIncidentResponse)
+  return false;
+#undef DO_
+}
+
+void ClientIncidentResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientIncidentResponse)
+  // optional bytes token = 1;
+  if (has_token()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->token(), output);
+  }
+
+  // optional bool download_requested = 2;
+  if (has_download_requested()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->download_requested(), output);
+  }
+
+  // repeated .safe_browsing.ClientIncidentResponse.EnvironmentRequest environment_requests = 3;
+  for (int i = 0; i < this->environment_requests_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->environment_requests(i), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientIncidentResponse)
+}
+
+int ClientIncidentResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes token = 1;
+    if (has_token()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->token());
+    }
+
+    // optional bool download_requested = 2;
+    if (has_download_requested()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated .safe_browsing.ClientIncidentResponse.EnvironmentRequest environment_requests = 3;
+  total_size += 1 * this->environment_requests_size();
+  for (int i = 0; i < this->environment_requests_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->environment_requests(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientIncidentResponse::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientIncidentResponse*>(&from));
+}
+
+void ClientIncidentResponse::MergeFrom(const ClientIncidentResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  environment_requests_.MergeFrom(from.environment_requests_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_token()) {
+      set_token(from.token());
+    }
+    if (from.has_download_requested()) {
+      set_download_requested(from.download_requested());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientIncidentResponse::CopyFrom(const ClientIncidentResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientIncidentResponse::IsInitialized() const {
+
+  return true;
+}
+
+void ClientIncidentResponse::Swap(ClientIncidentResponse* other) {
+  if (other != this) {
+    std::swap(token_, other->token_);
+    std::swap(download_requested_, other->download_requested_);
+    environment_requests_.Swap(&other->environment_requests_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientIncidentResponse::GetTypeName() const {
+  return "safe_browsing.ClientIncidentResponse";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DownloadMetadata::kDownloadIdFieldNumber;
+const int DownloadMetadata::kDownloadFieldNumber;
+#endif  // !_MSC_VER
+
+DownloadMetadata::DownloadMetadata()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.DownloadMetadata)
+}
+
+void DownloadMetadata::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  download_ = const_cast< ::safe_browsing::ClientIncidentReport_DownloadDetails*>(
+      ::safe_browsing::ClientIncidentReport_DownloadDetails::internal_default_instance());
+#else
+  download_ = const_cast< ::safe_browsing::ClientIncidentReport_DownloadDetails*>(&::safe_browsing::ClientIncidentReport_DownloadDetails::default_instance());
+#endif
+}
+
+DownloadMetadata::DownloadMetadata(const DownloadMetadata& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.DownloadMetadata)
+}
+
+void DownloadMetadata::SharedCtor() {
+  _cached_size_ = 0;
+  download_id_ = 0u;
+  download_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DownloadMetadata::~DownloadMetadata() {
+  // @@protoc_insertion_point(destructor:safe_browsing.DownloadMetadata)
+  SharedDtor();
+}
+
+void DownloadMetadata::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete download_;
+  }
+}
+
+void DownloadMetadata::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const DownloadMetadata& DownloadMetadata::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+DownloadMetadata* DownloadMetadata::default_instance_ = NULL;
+
+DownloadMetadata* DownloadMetadata::New() const {
+  return new DownloadMetadata;
+}
+
+void DownloadMetadata::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    download_id_ = 0u;
+    if (has_download()) {
+      if (download_ != NULL) download_->::safe_browsing::ClientIncidentReport_DownloadDetails::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool DownloadMetadata::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.DownloadMetadata)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 download_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &download_id_)));
+          set_has_download_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_download;
+        break;
+      }
+
+      // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_download:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_download()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.DownloadMetadata)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.DownloadMetadata)
+  return false;
+#undef DO_
+}
+
+void DownloadMetadata::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.DownloadMetadata)
+  // optional uint32 download_id = 1;
+  if (has_download_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->download_id(), output);
+  }
+
+  // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+  if (has_download()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->download(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.DownloadMetadata)
+}
+
+int DownloadMetadata::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 download_id = 1;
+    if (has_download_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->download_id());
+    }
+
+    // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+    if (has_download()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->download());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void DownloadMetadata::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const DownloadMetadata*>(&from));
+}
+
+void DownloadMetadata::MergeFrom(const DownloadMetadata& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_download_id()) {
+      set_download_id(from.download_id());
+    }
+    if (from.has_download()) {
+      mutable_download()->::safe_browsing::ClientIncidentReport_DownloadDetails::MergeFrom(from.download());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void DownloadMetadata::CopyFrom(const DownloadMetadata& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DownloadMetadata::IsInitialized() const {
+
+  if (has_download()) {
+    if (!this->download().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void DownloadMetadata::Swap(DownloadMetadata* other) {
+  if (other != this) {
+    std::swap(download_id_, other->download_id_);
+    std::swap(download_, other->download_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string DownloadMetadata::GetTypeName() const {
+  return "safe_browsing.DownloadMetadata";
+}
+
+
+// ===================================================================
+
+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:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::UNKNOWN;
+const ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::URL_PHISHING;
+const ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::URL_MALWARE;
+const ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::URL_UNWANTED;
+const ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::CLIENT_SIDE_PHISHING_URL;
+const ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::CLIENT_SIDE_MALWARE_URL;
+const ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::DANGEROUS_DOWNLOAD_RECOVERY;
+const ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::DANGEROUS_DOWNLOAD_WARNING;
+const ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::DANGEROUS_DOWNLOAD_BY_API;
+const ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::ReportType_MIN;
+const ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::ReportType_MAX;
+const int ClientSafeBrowsingReportRequest::ReportType_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int ClientSafeBrowsingReportRequest_HTTPHeader::kNameFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPHeader::kValueFieldNumber;
+#endif  // !_MSC_VER
+
+ClientSafeBrowsingReportRequest_HTTPHeader::ClientSafeBrowsingReportRequest_HTTPHeader()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::InitAsDefaultInstance() {
+}
+
+ClientSafeBrowsingReportRequest_HTTPHeader::ClientSafeBrowsingReportRequest_HTTPHeader(const ClientSafeBrowsingReportRequest_HTTPHeader& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientSafeBrowsingReportRequest_HTTPHeader::~ClientSafeBrowsingReportRequest_HTTPHeader() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+  SharedDtor();
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete value_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientSafeBrowsingReportRequest_HTTPHeader& ClientSafeBrowsingReportRequest_HTTPHeader::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPHeader::default_instance_ = NULL;
+
+ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPHeader::New() const {
+  return new ClientSafeBrowsingReportRequest_HTTPHeader;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    if (has_value()) {
+      if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        value_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPHeader::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required bytes name = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_name()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_value;
+        break;
+      }
+
+      // optional bytes value = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_value()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+  return false;
+#undef DO_
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+  // required bytes name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->name(), output);
+  }
+
+  // optional bytes value = 2;
+  if (has_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->value(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+}
+
+int ClientSafeBrowsingReportRequest_HTTPHeader::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required bytes name = 1;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->name());
+    }
+
+    // optional bytes value = 2;
+    if (has_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->value());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientSafeBrowsingReportRequest_HTTPHeader*>(&from));
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPHeader& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_value()) {
+      set_value(from.value());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientSafeBrowsingReportRequest_HTTPHeader::CopyFrom(const ClientSafeBrowsingReportRequest_HTTPHeader& from) {
+  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::Swap(ClientSafeBrowsingReportRequest_HTTPHeader* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    std::swap(value_, other->value_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientSafeBrowsingReportRequest_HTTPHeader::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::kVerbFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::kUriFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::kVersionFieldNumber;
+#endif  // !_MSC_VER
+
+ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::InitAsDefaultInstance() {
+}
+
+ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  verb_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  uri_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::~ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+  SharedDtor();
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::SharedDtor() {
+  if (verb_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete verb_;
+  }
+  if (uri_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete uri_;
+  }
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete version_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::default_instance_ = NULL;
+
+ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::New() const {
+  return new ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_verb()) {
+      if (verb_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        verb_->clear();
+      }
+    }
+    if (has_uri()) {
+      if (uri_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        uri_->clear();
+      }
+    }
+    if (has_version()) {
+      if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        version_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes verb = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_verb()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_uri;
+        break;
+      }
+
+      // optional bytes uri = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_uri:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_uri()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_version;
+        break;
+      }
+
+      // optional bytes version = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_version:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_version()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+  return false;
+#undef DO_
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+  // optional bytes verb = 1;
+  if (has_verb()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->verb(), output);
+  }
+
+  // optional bytes uri = 2;
+  if (has_uri()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->uri(), output);
+  }
+
+  // optional bytes version = 3;
+  if (has_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->version(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+}
+
+int ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes verb = 1;
+    if (has_verb()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->verb());
+    }
+
+    // optional bytes uri = 2;
+    if (has_uri()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->uri());
+    }
+
+    // optional bytes version = 3;
+    if (has_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->version());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine*>(&from));
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_verb()) {
+      set_verb(from.verb());
+    }
+    if (from.has_uri()) {
+      set_uri(from.uri());
+    }
+    if (from.has_version()) {
+      set_version(from.version());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::CopyFrom(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::IsInitialized() const {
+
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::Swap(ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* other) {
+  if (other != this) {
+    std::swap(verb_, other->verb_);
+    std::swap(uri_, other->uri_);
+    std::swap(version_, other->version_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientSafeBrowsingReportRequest_HTTPRequest::kFirstlineFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPRequest::kHeadersFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPRequest::kBodyFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPRequest::kBodydigestFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPRequest::kBodylengthFieldNumber;
+#endif  // !_MSC_VER
+
+ClientSafeBrowsingReportRequest_HTTPRequest::ClientSafeBrowsingReportRequest_HTTPRequest()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  firstline_ = const_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine*>(
+      ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::internal_default_instance());
+#else
+  firstline_ = const_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine*>(&::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::default_instance());
+#endif
+}
+
+ClientSafeBrowsingReportRequest_HTTPRequest::ClientSafeBrowsingReportRequest_HTTPRequest(const ClientSafeBrowsingReportRequest_HTTPRequest& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  firstline_ = NULL;
+  body_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  bodydigest_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  bodylength_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientSafeBrowsingReportRequest_HTTPRequest::~ClientSafeBrowsingReportRequest_HTTPRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+  SharedDtor();
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::SharedDtor() {
+  if (body_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete body_;
+  }
+  if (bodydigest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete bodydigest_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete firstline_;
+  }
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientSafeBrowsingReportRequest_HTTPRequest& ClientSafeBrowsingReportRequest_HTTPRequest::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientSafeBrowsingReportRequest_HTTPRequest* ClientSafeBrowsingReportRequest_HTTPRequest::default_instance_ = NULL;
+
+ClientSafeBrowsingReportRequest_HTTPRequest* ClientSafeBrowsingReportRequest_HTTPRequest::New() const {
+  return new ClientSafeBrowsingReportRequest_HTTPRequest;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::Clear() {
+  if (_has_bits_[0 / 32] & 29) {
+    if (has_firstline()) {
+      if (firstline_ != NULL) firstline_->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::Clear();
+    }
+    if (has_body()) {
+      if (body_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        body_->clear();
+      }
+    }
+    if (has_bodydigest()) {
+      if (bodydigest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        bodydigest_->clear();
+      }
+    }
+    bodylength_ = 0;
+  }
+  headers_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine firstline = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_firstline()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_headers;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_headers:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_headers()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_headers;
+        if (input->ExpectTag(26)) goto parse_body;
+        break;
+      }
+
+      // optional bytes body = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_body:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_body()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_bodydigest;
+        break;
+      }
+
+      // optional bytes bodydigest = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_bodydigest:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_bodydigest()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_bodylength;
+        break;
+      }
+
+      // optional int32 bodylength = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_bodylength:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &bodylength_)));
+          set_has_bodylength();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+  return false;
+#undef DO_
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine firstline = 1;
+  if (has_firstline()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->firstline(), output);
+  }
+
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+  for (int i = 0; i < this->headers_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->headers(i), output);
+  }
+
+  // optional bytes body = 3;
+  if (has_body()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->body(), output);
+  }
+
+  // optional bytes bodydigest = 4;
+  if (has_bodydigest()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      4, this->bodydigest(), output);
+  }
+
+  // optional int32 bodylength = 5;
+  if (has_bodylength()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->bodylength(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+}
+
+int ClientSafeBrowsingReportRequest_HTTPRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine firstline = 1;
+    if (has_firstline()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->firstline());
+    }
+
+    // optional bytes body = 3;
+    if (has_body()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->body());
+    }
+
+    // optional bytes bodydigest = 4;
+    if (has_bodydigest()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->bodydigest());
+    }
+
+    // optional int32 bodylength = 5;
+    if (has_bodylength()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->bodylength());
+    }
+
+  }
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+  total_size += 1 * this->headers_size();
+  for (int i = 0; i < this->headers_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->headers(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientSafeBrowsingReportRequest_HTTPRequest*>(&from));
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  headers_.MergeFrom(from.headers_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_firstline()) {
+      mutable_firstline()->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::MergeFrom(from.firstline());
+    }
+    if (from.has_body()) {
+      set_body(from.body());
+    }
+    if (from.has_bodydigest()) {
+      set_bodydigest(from.bodydigest());
+    }
+    if (from.has_bodylength()) {
+      set_bodylength(from.bodylength());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::CopyFrom(const ClientSafeBrowsingReportRequest_HTTPRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPRequest::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->headers())) return false;
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPRequest::Swap(ClientSafeBrowsingReportRequest_HTTPRequest* other) {
+  if (other != this) {
+    std::swap(firstline_, other->firstline_);
+    headers_.Swap(&other->headers_);
+    std::swap(body_, other->body_);
+    std::swap(bodydigest_, other->bodydigest_);
+    std::swap(bodylength_, other->bodylength_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientSafeBrowsingReportRequest_HTTPRequest::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::kCodeFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::kReasonFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::kVersionFieldNumber;
+#endif  // !_MSC_VER
+
+ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::InitAsDefaultInstance() {
+}
+
+ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  code_ = 0;
+  reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::~ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+  SharedDtor();
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::SharedDtor() {
+  if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete reason_;
+  }
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete version_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::default_instance_ = NULL;
+
+ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::New() const {
+  return new ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    code_ = 0;
+    if (has_reason()) {
+      if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        reason_->clear();
+      }
+    }
+    if (has_version()) {
+      if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        version_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional int32 code = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &code_)));
+          set_has_code();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_reason;
+        break;
+      }
+
+      // optional bytes reason = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_reason:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_reason()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_version;
+        break;
+      }
+
+      // optional bytes version = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_version:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_version()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+  return false;
+#undef DO_
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+  // optional int32 code = 1;
+  if (has_code()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->code(), output);
+  }
+
+  // optional bytes reason = 2;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->reason(), output);
+  }
+
+  // optional bytes version = 3;
+  if (has_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->version(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+}
+
+int ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional int32 code = 1;
+    if (has_code()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->code());
+    }
+
+    // optional bytes reason = 2;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->reason());
+    }
+
+    // optional bytes version = 3;
+    if (has_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->version());
+    }
+
+  }
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine*>(&from));
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_code()) {
+      set_code(from.code());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+    if (from.has_version()) {
+      set_version(from.version());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::CopyFrom(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::IsInitialized() const {
+
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::Swap(ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* other) {
+  if (other != this) {
+    std::swap(code_, other->code_);
+    std::swap(reason_, other->reason_);
+    std::swap(version_, other->version_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientSafeBrowsingReportRequest_HTTPResponse::kFirstlineFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPResponse::kHeadersFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPResponse::kBodyFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPResponse::kBodydigestFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPResponse::kBodylengthFieldNumber;
+const int ClientSafeBrowsingReportRequest_HTTPResponse::kRemoteIpFieldNumber;
+#endif  // !_MSC_VER
+
+ClientSafeBrowsingReportRequest_HTTPResponse::ClientSafeBrowsingReportRequest_HTTPResponse()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  firstline_ = const_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine*>(
+      ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::internal_default_instance());
+#else
+  firstline_ = const_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine*>(&::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::default_instance());
+#endif
+}
+
+ClientSafeBrowsingReportRequest_HTTPResponse::ClientSafeBrowsingReportRequest_HTTPResponse(const ClientSafeBrowsingReportRequest_HTTPResponse& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  firstline_ = NULL;
+  body_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  bodydigest_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  bodylength_ = 0;
+  remote_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientSafeBrowsingReportRequest_HTTPResponse::~ClientSafeBrowsingReportRequest_HTTPResponse() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+  SharedDtor();
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::SharedDtor() {
+  if (body_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete body_;
+  }
+  if (bodydigest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete bodydigest_;
+  }
+  if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete remote_ip_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete firstline_;
+  }
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientSafeBrowsingReportRequest_HTTPResponse& ClientSafeBrowsingReportRequest_HTTPResponse::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientSafeBrowsingReportRequest_HTTPResponse* ClientSafeBrowsingReportRequest_HTTPResponse::default_instance_ = NULL;
+
+ClientSafeBrowsingReportRequest_HTTPResponse* ClientSafeBrowsingReportRequest_HTTPResponse::New() const {
+  return new ClientSafeBrowsingReportRequest_HTTPResponse;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::Clear() {
+  if (_has_bits_[0 / 32] & 61) {
+    if (has_firstline()) {
+      if (firstline_ != NULL) firstline_->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::Clear();
+    }
+    if (has_body()) {
+      if (body_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        body_->clear();
+      }
+    }
+    if (has_bodydigest()) {
+      if (bodydigest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        bodydigest_->clear();
+      }
+    }
+    bodylength_ = 0;
+    if (has_remote_ip()) {
+      if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        remote_ip_->clear();
+      }
+    }
+  }
+  headers_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine firstline = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_firstline()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_headers;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_headers:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_headers()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_headers;
+        if (input->ExpectTag(26)) goto parse_body;
+        break;
+      }
+
+      // optional bytes body = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_body:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_body()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_bodydigest;
+        break;
+      }
+
+      // optional bytes bodydigest = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_bodydigest:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_bodydigest()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_bodylength;
+        break;
+      }
+
+      // optional int32 bodylength = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_bodylength:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &bodylength_)));
+          set_has_bodylength();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_remote_ip;
+        break;
+      }
+
+      // optional bytes remote_ip = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_remote_ip:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_remote_ip()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+  return false;
+#undef DO_
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine firstline = 1;
+  if (has_firstline()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->firstline(), output);
+  }
+
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+  for (int i = 0; i < this->headers_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->headers(i), output);
+  }
+
+  // optional bytes body = 3;
+  if (has_body()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->body(), output);
+  }
+
+  // optional bytes bodydigest = 4;
+  if (has_bodydigest()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      4, this->bodydigest(), output);
+  }
+
+  // optional int32 bodylength = 5;
+  if (has_bodylength()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->bodylength(), output);
+  }
+
+  // optional bytes remote_ip = 6;
+  if (has_remote_ip()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      6, this->remote_ip(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+}
+
+int ClientSafeBrowsingReportRequest_HTTPResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine firstline = 1;
+    if (has_firstline()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->firstline());
+    }
+
+    // optional bytes body = 3;
+    if (has_body()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->body());
+    }
+
+    // optional bytes bodydigest = 4;
+    if (has_bodydigest()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->bodydigest());
+    }
+
+    // optional int32 bodylength = 5;
+    if (has_bodylength()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->bodylength());
+    }
+
+    // optional bytes remote_ip = 6;
+    if (has_remote_ip()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->remote_ip());
+    }
+
+  }
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+  total_size += 1 * this->headers_size();
+  for (int i = 0; i < this->headers_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->headers(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientSafeBrowsingReportRequest_HTTPResponse*>(&from));
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::MergeFrom(const ClientSafeBrowsingReportRequest_HTTPResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  headers_.MergeFrom(from.headers_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_firstline()) {
+      mutable_firstline()->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::MergeFrom(from.firstline());
+    }
+    if (from.has_body()) {
+      set_body(from.body());
+    }
+    if (from.has_bodydigest()) {
+      set_bodydigest(from.bodydigest());
+    }
+    if (from.has_bodylength()) {
+      set_bodylength(from.bodylength());
+    }
+    if (from.has_remote_ip()) {
+      set_remote_ip(from.remote_ip());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::CopyFrom(const ClientSafeBrowsingReportRequest_HTTPResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest_HTTPResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->headers())) return false;
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest_HTTPResponse::Swap(ClientSafeBrowsingReportRequest_HTTPResponse* other) {
+  if (other != this) {
+    std::swap(firstline_, other->firstline_);
+    headers_.Swap(&other->headers_);
+    std::swap(body_, other->body_);
+    std::swap(bodydigest_, other->bodydigest_);
+    std::swap(bodylength_, other->bodylength_);
+    std::swap(remote_ip_, other->remote_ip_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientSafeBrowsingReportRequest_HTTPResponse::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientSafeBrowsingReportRequest_Resource::kIdFieldNumber;
+const int ClientSafeBrowsingReportRequest_Resource::kUrlFieldNumber;
+const int ClientSafeBrowsingReportRequest_Resource::kRequestFieldNumber;
+const int ClientSafeBrowsingReportRequest_Resource::kResponseFieldNumber;
+const int ClientSafeBrowsingReportRequest_Resource::kParentIdFieldNumber;
+const int ClientSafeBrowsingReportRequest_Resource::kChildIdsFieldNumber;
+const int ClientSafeBrowsingReportRequest_Resource::kTagNameFieldNumber;
+#endif  // !_MSC_VER
+
+ClientSafeBrowsingReportRequest_Resource::ClientSafeBrowsingReportRequest_Resource()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+}
+
+void ClientSafeBrowsingReportRequest_Resource::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  request_ = const_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest*>(
+      ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest::internal_default_instance());
+#else
+  request_ = const_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest*>(&::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  response_ = const_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse*>(
+      ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse::internal_default_instance());
+#else
+  response_ = const_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse*>(&::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse::default_instance());
+#endif
+}
+
+ClientSafeBrowsingReportRequest_Resource::ClientSafeBrowsingReportRequest_Resource(const ClientSafeBrowsingReportRequest_Resource& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+}
+
+void ClientSafeBrowsingReportRequest_Resource::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = 0;
+  url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  request_ = NULL;
+  response_ = NULL;
+  parent_id_ = 0;
+  tag_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientSafeBrowsingReportRequest_Resource::~ClientSafeBrowsingReportRequest_Resource() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+  SharedDtor();
+}
+
+void ClientSafeBrowsingReportRequest_Resource::SharedDtor() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (tag_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete tag_name_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete request_;
+    delete response_;
+  }
+}
+
+void ClientSafeBrowsingReportRequest_Resource::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientSafeBrowsingReportRequest_Resource& ClientSafeBrowsingReportRequest_Resource::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientSafeBrowsingReportRequest_Resource* ClientSafeBrowsingReportRequest_Resource::default_instance_ = NULL;
+
+ClientSafeBrowsingReportRequest_Resource* ClientSafeBrowsingReportRequest_Resource::New() const {
+  return new ClientSafeBrowsingReportRequest_Resource;
+}
+
+void ClientSafeBrowsingReportRequest_Resource::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClientSafeBrowsingReportRequest_Resource*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 95) {
+    ZR_(id_, parent_id_);
+    if (has_url()) {
+      if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_->clear();
+      }
+    }
+    if (has_request()) {
+      if (request_ != NULL) request_->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest::Clear();
+    }
+    if (has_response()) {
+      if (response_ != NULL) response_->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse::Clear();
+    }
+    if (has_tag_name()) {
+      if (tag_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        tag_name_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  child_ids_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientSafeBrowsingReportRequest_Resource::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required int32 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_url;
+        break;
+      }
+
+      // optional string url = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_url:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_request;
+        break;
+      }
+
+      // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest request = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_request:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_request()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_response;
+        break;
+      }
+
+      // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse response = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_response:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_response()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_parent_id;
+        break;
+      }
+
+      // optional int32 parent_id = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_parent_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &parent_id_)));
+          set_has_parent_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_child_ids;
+        break;
+      }
+
+      // repeated int32 child_ids = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_child_ids:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 1, 48, input, this->mutable_child_ids())));
+        } else if (tag == 50) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, this->mutable_child_ids())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_child_ids;
+        if (input->ExpectTag(58)) goto parse_tag_name;
+        break;
+      }
+
+      // optional string tag_name = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_tag_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_tag_name()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+  return false;
+#undef DO_
+}
+
+void ClientSafeBrowsingReportRequest_Resource::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+  // required int32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->id(), output);
+  }
+
+  // optional string url = 2;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->url(), output);
+  }
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest request = 3;
+  if (has_request()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->request(), output);
+  }
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse response = 4;
+  if (has_response()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->response(), output);
+  }
+
+  // optional int32 parent_id = 5;
+  if (has_parent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->parent_id(), output);
+  }
+
+  // repeated int32 child_ids = 6;
+  for (int i = 0; i < this->child_ids_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(
+      6, this->child_ids(i), output);
+  }
+
+  // optional string tag_name = 7;
+  if (has_tag_name()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      7, this->tag_name(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+}
+
+int ClientSafeBrowsingReportRequest_Resource::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required int32 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->id());
+    }
+
+    // optional string url = 2;
+    if (has_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->url());
+    }
+
+    // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest request = 3;
+    if (has_request()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->request());
+    }
+
+    // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse response = 4;
+    if (has_response()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->response());
+    }
+
+    // optional int32 parent_id = 5;
+    if (has_parent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->parent_id());
+    }
+
+    // optional string tag_name = 7;
+    if (has_tag_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->tag_name());
+    }
+
+  }
+  // repeated int32 child_ids = 6;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->child_ids_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        Int32Size(this->child_ids(i));
+    }
+    total_size += 1 * this->child_ids_size() + data_size;
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest_Resource::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientSafeBrowsingReportRequest_Resource*>(&from));
+}
+
+void ClientSafeBrowsingReportRequest_Resource::MergeFrom(const ClientSafeBrowsingReportRequest_Resource& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  child_ids_.MergeFrom(from.child_ids_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_url()) {
+      set_url(from.url());
+    }
+    if (from.has_request()) {
+      mutable_request()->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest::MergeFrom(from.request());
+    }
+    if (from.has_response()) {
+      mutable_response()->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse::MergeFrom(from.response());
+    }
+    if (from.has_parent_id()) {
+      set_parent_id(from.parent_id());
+    }
+    if (from.has_tag_name()) {
+      set_tag_name(from.tag_name());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientSafeBrowsingReportRequest_Resource::CopyFrom(const ClientSafeBrowsingReportRequest_Resource& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest_Resource::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_request()) {
+    if (!this->request().IsInitialized()) return false;
+  }
+  if (has_response()) {
+    if (!this->response().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest_Resource::Swap(ClientSafeBrowsingReportRequest_Resource* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(url_, other->url_);
+    std::swap(request_, other->request_);
+    std::swap(response_, other->response_);
+    std::swap(parent_id_, other->parent_id_);
+    child_ids_.Swap(&other->child_ids_);
+    std::swap(tag_name_, other->tag_name_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientSafeBrowsingReportRequest_Resource::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest.Resource";
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int ClientSafeBrowsingReportRequest::kTypeFieldNumber;
+const int ClientSafeBrowsingReportRequest::kDownloadVerdictFieldNumber;
+const int ClientSafeBrowsingReportRequest::kUrlFieldNumber;
+const int ClientSafeBrowsingReportRequest::kPageUrlFieldNumber;
+const int ClientSafeBrowsingReportRequest::kReferrerUrlFieldNumber;
+const int ClientSafeBrowsingReportRequest::kResourcesFieldNumber;
+const int ClientSafeBrowsingReportRequest::kCompleteFieldNumber;
+const int ClientSafeBrowsingReportRequest::kClientAsnFieldNumber;
+const int ClientSafeBrowsingReportRequest::kClientCountryFieldNumber;
+const int ClientSafeBrowsingReportRequest::kDidProceedFieldNumber;
+const int ClientSafeBrowsingReportRequest::kRepeatVisitFieldNumber;
+const int ClientSafeBrowsingReportRequest::kTokenFieldNumber;
+#endif  // !_MSC_VER
+
+ClientSafeBrowsingReportRequest::ClientSafeBrowsingReportRequest()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:safe_browsing.ClientSafeBrowsingReportRequest)
+}
+
+void ClientSafeBrowsingReportRequest::InitAsDefaultInstance() {
+}
+
+ClientSafeBrowsingReportRequest::ClientSafeBrowsingReportRequest(const ClientSafeBrowsingReportRequest& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:safe_browsing.ClientSafeBrowsingReportRequest)
+}
+
+void ClientSafeBrowsingReportRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  type_ = 0;
+  download_verdict_ = 0;
+  url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  page_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  referrer_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  complete_ = false;
+  client_country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  did_proceed_ = false;
+  repeat_visit_ = false;
+  token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientSafeBrowsingReportRequest::~ClientSafeBrowsingReportRequest() {
+  // @@protoc_insertion_point(destructor:safe_browsing.ClientSafeBrowsingReportRequest)
+  SharedDtor();
+}
+
+void ClientSafeBrowsingReportRequest::SharedDtor() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (page_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete page_url_;
+  }
+  if (referrer_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete referrer_url_;
+  }
+  if (client_country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_country_;
+  }
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete token_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void ClientSafeBrowsingReportRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ClientSafeBrowsingReportRequest& ClientSafeBrowsingReportRequest::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+#endif
+  return *default_instance_;
+}
+
+ClientSafeBrowsingReportRequest* ClientSafeBrowsingReportRequest::default_instance_ = NULL;
+
+ClientSafeBrowsingReportRequest* ClientSafeBrowsingReportRequest::New() const {
+  return new ClientSafeBrowsingReportRequest;
+}
+
+void ClientSafeBrowsingReportRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClientSafeBrowsingReportRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 95) {
+    ZR_(type_, download_verdict_);
+    if (has_url()) {
+      if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_->clear();
+      }
+    }
+    if (has_page_url()) {
+      if (page_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        page_url_->clear();
+      }
+    }
+    if (has_referrer_url()) {
+      if (referrer_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        referrer_url_->clear();
+      }
+    }
+    complete_ = false;
+  }
+  if (_has_bits_[8 / 32] & 3840) {
+    ZR_(did_proceed_, repeat_visit_);
+    if (has_client_country()) {
+      if (client_country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        client_country_->clear();
+      }
+    }
+    if (has_token()) {
+      if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        token_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  resources_.Clear();
+  client_asn_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->clear();
+}
+
+bool ClientSafeBrowsingReportRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  ::google::protobuf::io::StringOutputStream unknown_fields_string(
+      mutable_unknown_fields());
+  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
+      &unknown_fields_string);
+  // @@protoc_insertion_point(parse_start:safe_browsing.ClientSafeBrowsingReportRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string url = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_page_url;
+        break;
+      }
+
+      // optional string page_url = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_page_url:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_page_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_referrer_url;
+        break;
+      }
+
+      // optional string referrer_url = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_referrer_url:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_referrer_url()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_resources;
+        break;
+      }
+
+      // repeated .safe_browsing.ClientSafeBrowsingReportRequest.Resource resources = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_resources:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_resources()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_resources;
+        if (input->ExpectTag(40)) goto parse_complete;
+        break;
+      }
+
+      // optional bool complete = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_complete:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &complete_)));
+          set_has_complete();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_client_asn;
+        break;
+      }
+
+      // repeated string client_asn = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_client_asn:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_client_asn()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_client_asn;
+        if (input->ExpectTag(58)) goto parse_client_country;
+        break;
+      }
+
+      // optional string client_country = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_client_country:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_client_country()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_did_proceed;
+        break;
+      }
+
+      // optional bool did_proceed = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_did_proceed:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &did_proceed_)));
+          set_has_did_proceed();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(72)) goto parse_repeat_visit;
+        break;
+      }
+
+      // optional bool repeat_visit = 9;
+      case 9: {
+        if (tag == 72) {
+         parse_repeat_visit:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &repeat_visit_)));
+          set_has_repeat_visit();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(80)) goto parse_type;
+        break;
+      }
+
+      // optional .safe_browsing.ClientSafeBrowsingReportRequest.ReportType type = 10;
+      case 10: {
+        if (tag == 80) {
+         parse_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientSafeBrowsingReportRequest_ReportType_IsValid(value)) {
+            set_type(static_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_ReportType >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(88)) goto parse_download_verdict;
+        break;
+      }
+
+      // optional .safe_browsing.ClientDownloadResponse.Verdict download_verdict = 11;
+      case 11: {
+        if (tag == 88) {
+         parse_download_verdict:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::safe_browsing::ClientDownloadResponse_Verdict_IsValid(value)) {
+            set_download_verdict(static_cast< ::safe_browsing::ClientDownloadResponse_Verdict >(value));
+          } else {
+            unknown_fields_stream.WriteVarint32(tag);
+            unknown_fields_stream.WriteVarint32(value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(122)) goto parse_token;
+        break;
+      }
+
+      // optional bytes token = 15;
+      case 15: {
+        if (tag == 122) {
+         parse_token:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_token()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
+            input, tag, &unknown_fields_stream));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:safe_browsing.ClientSafeBrowsingReportRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:safe_browsing.ClientSafeBrowsingReportRequest)
+  return false;
+#undef DO_
+}
+
+void ClientSafeBrowsingReportRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:safe_browsing.ClientSafeBrowsingReportRequest)
+  // optional string url = 1;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->url(), output);
+  }
+
+  // optional string page_url = 2;
+  if (has_page_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->page_url(), output);
+  }
+
+  // optional string referrer_url = 3;
+  if (has_referrer_url()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->referrer_url(), output);
+  }
+
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.Resource resources = 4;
+  for (int i = 0; i < this->resources_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->resources(i), output);
+  }
+
+  // optional bool complete = 5;
+  if (has_complete()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->complete(), output);
+  }
+
+  // repeated string client_asn = 6;
+  for (int i = 0; i < this->client_asn_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      6, this->client_asn(i), output);
+  }
+
+  // optional string client_country = 7;
+  if (has_client_country()) {
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      7, this->client_country(), output);
+  }
+
+  // optional bool did_proceed = 8;
+  if (has_did_proceed()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->did_proceed(), output);
+  }
+
+  // optional bool repeat_visit = 9;
+  if (has_repeat_visit()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->repeat_visit(), output);
+  }
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.ReportType type = 10;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      10, this->type(), output);
+  }
+
+  // optional .safe_browsing.ClientDownloadResponse.Verdict download_verdict = 11;
+  if (has_download_verdict()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      11, this->download_verdict(), output);
+  }
+
+  // optional bytes token = 15;
+  if (has_token()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      15, this->token(), output);
+  }
+
+  output->WriteRaw(unknown_fields().data(),
+                   unknown_fields().size());
+  // @@protoc_insertion_point(serialize_end:safe_browsing.ClientSafeBrowsingReportRequest)
+}
+
+int ClientSafeBrowsingReportRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .safe_browsing.ClientSafeBrowsingReportRequest.ReportType type = 10;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
+    }
+
+    // optional .safe_browsing.ClientDownloadResponse.Verdict download_verdict = 11;
+    if (has_download_verdict()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->download_verdict());
+    }
+
+    // optional string url = 1;
+    if (has_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->url());
+    }
+
+    // optional string page_url = 2;
+    if (has_page_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->page_url());
+    }
+
+    // optional string referrer_url = 3;
+    if (has_referrer_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->referrer_url());
+    }
+
+    // optional bool complete = 5;
+    if (has_complete()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional string client_country = 7;
+    if (has_client_country()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->client_country());
+    }
+
+    // optional bool did_proceed = 8;
+    if (has_did_proceed()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool repeat_visit = 9;
+    if (has_repeat_visit()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bytes token = 15;
+    if (has_token()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->token());
+    }
+
+  }
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.Resource resources = 4;
+  total_size += 1 * this->resources_size();
+  for (int i = 0; i < this->resources_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->resources(i));
+  }
+
+  // repeated string client_asn = 6;
+  total_size += 1 * this->client_asn_size();
+  for (int i = 0; i < this->client_asn_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->client_asn(i));
+  }
+
+  total_size += unknown_fields().size();
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientSafeBrowsingReportRequest::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClientSafeBrowsingReportRequest*>(&from));
+}
+
+void ClientSafeBrowsingReportRequest::MergeFrom(const ClientSafeBrowsingReportRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  resources_.MergeFrom(from.resources_);
+  client_asn_.MergeFrom(from.client_asn_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_download_verdict()) {
+      set_download_verdict(from.download_verdict());
+    }
+    if (from.has_url()) {
+      set_url(from.url());
+    }
+    if (from.has_page_url()) {
+      set_page_url(from.page_url());
+    }
+    if (from.has_referrer_url()) {
+      set_referrer_url(from.referrer_url());
+    }
+    if (from.has_complete()) {
+      set_complete(from.complete());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_client_country()) {
+      set_client_country(from.client_country());
+    }
+    if (from.has_did_proceed()) {
+      set_did_proceed(from.did_proceed());
+    }
+    if (from.has_repeat_visit()) {
+      set_repeat_visit(from.repeat_visit());
+    }
+    if (from.has_token()) {
+      set_token(from.token());
+    }
+  }
+  mutable_unknown_fields()->append(from.unknown_fields());
+}
+
+void ClientSafeBrowsingReportRequest::CopyFrom(const ClientSafeBrowsingReportRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientSafeBrowsingReportRequest::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->resources())) return false;
+  return true;
+}
+
+void ClientSafeBrowsingReportRequest::Swap(ClientSafeBrowsingReportRequest* other) {
+  if (other != this) {
+    std::swap(type_, other->type_);
+    std::swap(download_verdict_, other->download_verdict_);
+    std::swap(url_, other->url_);
+    std::swap(page_url_, other->page_url_);
+    std::swap(referrer_url_, other->referrer_url_);
+    resources_.Swap(&other->resources_);
+    std::swap(complete_, other->complete_);
+    client_asn_.Swap(&other->client_asn_);
+    std::swap(client_country_, other->client_country_);
+    std::swap(did_proceed_, other->did_proceed_);
+    std::swap(repeat_visit_, other->repeat_visit_);
+    std::swap(token_, other->token_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.swap(other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ClientSafeBrowsingReportRequest::GetTypeName() const {
+  return "safe_browsing.ClientSafeBrowsingReportRequest";
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace safe_browsing
+
+// @@protoc_insertion_point(global_scope)
diff --git a/toolkit/components/downloads/chromium/chrome/common/safe_browsing/csd.pb.h b/toolkit/components/downloads/chromium/chrome/common/safe_browsing/csd.pb.h
new file mode 100644
index 000000000..0ec320b66
--- /dev/null
+++ b/toolkit/components/downloads/chromium/chrome/common/safe_browsing/csd.pb.h
@@ -0,0 +1,21771 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: chromium/chrome/common/safe_browsing/csd.proto
+
+#ifndef PROTOBUF_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto__INCLUDED
+#define PROTOBUF_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+// @@protoc_insertion_point(includes)
+
+namespace safe_browsing {
+
+// Internal implementation detail -- do not call these.
+void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+class ChromeUserPopulation;
+class ClientPhishingRequest;
+class ClientPhishingRequest_Feature;
+class ClientPhishingResponse;
+class ClientMalwareRequest;
+class ClientMalwareRequest_UrlInfo;
+class ClientMalwareResponse;
+class ClientDownloadRequest;
+class ClientDownloadRequest_Digests;
+class ClientDownloadRequest_Resource;
+class ClientDownloadRequest_CertificateChain;
+class ClientDownloadRequest_CertificateChain_Element;
+class ClientDownloadRequest_ExtendedAttr;
+class ClientDownloadRequest_SignatureInfo;
+class ClientDownloadRequest_PEImageHeaders;
+class ClientDownloadRequest_PEImageHeaders_DebugData;
+class ClientDownloadRequest_MachOHeaders;
+class ClientDownloadRequest_MachOHeaders_LoadCommand;
+class ClientDownloadRequest_ImageHeaders;
+class ClientDownloadRequest_ArchivedBinary;
+class ClientDownloadRequest_URLChainEntry;
+class ClientDownloadResponse;
+class ClientDownloadResponse_MoreInfo;
+class ClientDownloadReport;
+class ClientDownloadReport_UserInformation;
+class ClientUploadResponse;
+class ClientIncidentReport;
+class ClientIncidentReport_IncidentData;
+class ClientIncidentReport_IncidentData_TrackedPreferenceIncident;
+class ClientIncidentReport_IncidentData_BinaryIntegrityIncident;
+class ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile;
+class ClientIncidentReport_IncidentData_BlacklistLoadIncident;
+class ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident;
+class ClientIncidentReport_IncidentData_ResourceRequestIncident;
+class ClientIncidentReport_IncidentData_SuspiciousModuleIncident;
+class ClientIncidentReport_DownloadDetails;
+class ClientIncidentReport_EnvironmentData;
+class ClientIncidentReport_EnvironmentData_OS;
+class ClientIncidentReport_EnvironmentData_OS_RegistryValue;
+class ClientIncidentReport_EnvironmentData_OS_RegistryKey;
+class ClientIncidentReport_EnvironmentData_Machine;
+class ClientIncidentReport_EnvironmentData_Process;
+class ClientIncidentReport_EnvironmentData_Process_Patch;
+class ClientIncidentReport_EnvironmentData_Process_NetworkProvider;
+class ClientIncidentReport_EnvironmentData_Process_Dll;
+class ClientIncidentReport_EnvironmentData_Process_ModuleState;
+class ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification;
+class ClientIncidentReport_ExtensionData;
+class ClientIncidentReport_ExtensionData_ExtensionInfo;
+class ClientIncidentReport_NonBinaryDownloadDetails;
+class ClientIncidentResponse;
+class ClientIncidentResponse_EnvironmentRequest;
+class DownloadMetadata;
+class ClientSafeBrowsingReportRequest;
+class ClientSafeBrowsingReportRequest_HTTPHeader;
+class ClientSafeBrowsingReportRequest_HTTPRequest;
+class ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine;
+class ClientSafeBrowsingReportRequest_HTTPResponse;
+class ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine;
+class ClientSafeBrowsingReportRequest_Resource;
+
+enum ChromeUserPopulation_UserPopulation {
+  ChromeUserPopulation_UserPopulation_UNKNOWN_USER_POPULATION = 0,
+  ChromeUserPopulation_UserPopulation_SAFE_BROWSING = 1,
+  ChromeUserPopulation_UserPopulation_EXTENDED_REPORTING = 2
+};
+bool ChromeUserPopulation_UserPopulation_IsValid(int value);
+const ChromeUserPopulation_UserPopulation ChromeUserPopulation_UserPopulation_UserPopulation_MIN = ChromeUserPopulation_UserPopulation_UNKNOWN_USER_POPULATION;
+const ChromeUserPopulation_UserPopulation ChromeUserPopulation_UserPopulation_UserPopulation_MAX = ChromeUserPopulation_UserPopulation_EXTENDED_REPORTING;
+const int ChromeUserPopulation_UserPopulation_UserPopulation_ARRAYSIZE = ChromeUserPopulation_UserPopulation_UserPopulation_MAX + 1;
+
+enum ClientDownloadRequest_URLChainEntry_URLType {
+  ClientDownloadRequest_URLChainEntry_URLType_DOWNLOAD_URL = 1,
+  ClientDownloadRequest_URLChainEntry_URLType_DOWNLOAD_REFERRER = 2,
+  ClientDownloadRequest_URLChainEntry_URLType_LANDING_PAGE = 3,
+  ClientDownloadRequest_URLChainEntry_URLType_LANDING_REFERRER = 4,
+  ClientDownloadRequest_URLChainEntry_URLType_CLIENT_REDIRECT = 5,
+  ClientDownloadRequest_URLChainEntry_URLType_SERVER_REDIRECT = 6
+};
+bool ClientDownloadRequest_URLChainEntry_URLType_IsValid(int value);
+const ClientDownloadRequest_URLChainEntry_URLType ClientDownloadRequest_URLChainEntry_URLType_URLType_MIN = ClientDownloadRequest_URLChainEntry_URLType_DOWNLOAD_URL;
+const ClientDownloadRequest_URLChainEntry_URLType ClientDownloadRequest_URLChainEntry_URLType_URLType_MAX = ClientDownloadRequest_URLChainEntry_URLType_SERVER_REDIRECT;
+const int ClientDownloadRequest_URLChainEntry_URLType_URLType_ARRAYSIZE = ClientDownloadRequest_URLChainEntry_URLType_URLType_MAX + 1;
+
+enum ClientDownloadRequest_ResourceType {
+  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);
+const ClientDownloadRequest_ResourceType ClientDownloadRequest_ResourceType_ResourceType_MIN = ClientDownloadRequest_ResourceType_DOWNLOAD_URL;
+const ClientDownloadRequest_ResourceType ClientDownloadRequest_ResourceType_ResourceType_MAX = ClientDownloadRequest_ResourceType_PPAPI_PLUGIN;
+const int ClientDownloadRequest_ResourceType_ResourceType_ARRAYSIZE = ClientDownloadRequest_ResourceType_ResourceType_MAX + 1;
+
+enum ClientDownloadRequest_DownloadType {
+  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);
+const ClientDownloadRequest_DownloadType ClientDownloadRequest_DownloadType_DownloadType_MIN = ClientDownloadRequest_DownloadType_WIN_EXECUTABLE;
+const ClientDownloadRequest_DownloadType ClientDownloadRequest_DownloadType_DownloadType_MAX = ClientDownloadRequest_DownloadType_SAMPLED_UNSUPPORTED_FILE;
+const int ClientDownloadRequest_DownloadType_DownloadType_ARRAYSIZE = ClientDownloadRequest_DownloadType_DownloadType_MAX + 1;
+
+enum ClientDownloadResponse_Verdict {
+  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);
+const ClientDownloadResponse_Verdict ClientDownloadResponse_Verdict_Verdict_MIN = ClientDownloadResponse_Verdict_SAFE;
+const ClientDownloadResponse_Verdict ClientDownloadResponse_Verdict_Verdict_MAX = ClientDownloadResponse_Verdict_UNKNOWN;
+const int ClientDownloadResponse_Verdict_Verdict_ARRAYSIZE = ClientDownloadResponse_Verdict_Verdict_MAX + 1;
+
+enum ClientDownloadReport_Reason {
+  ClientDownloadReport_Reason_SHARE = 0,
+  ClientDownloadReport_Reason_FALSE_POSITIVE = 1,
+  ClientDownloadReport_Reason_APPEAL = 2
+};
+bool ClientDownloadReport_Reason_IsValid(int value);
+const ClientDownloadReport_Reason ClientDownloadReport_Reason_Reason_MIN = ClientDownloadReport_Reason_SHARE;
+const ClientDownloadReport_Reason ClientDownloadReport_Reason_Reason_MAX = ClientDownloadReport_Reason_APPEAL;
+const int ClientDownloadReport_Reason_Reason_ARRAYSIZE = ClientDownloadReport_Reason_Reason_MAX + 1;
+
+enum ClientUploadResponse_UploadStatus {
+  ClientUploadResponse_UploadStatus_SUCCESS = 0,
+  ClientUploadResponse_UploadStatus_UPLOAD_FAILURE = 1
+};
+bool ClientUploadResponse_UploadStatus_IsValid(int value);
+const ClientUploadResponse_UploadStatus ClientUploadResponse_UploadStatus_UploadStatus_MIN = ClientUploadResponse_UploadStatus_SUCCESS;
+const ClientUploadResponse_UploadStatus ClientUploadResponse_UploadStatus_UploadStatus_MAX = ClientUploadResponse_UploadStatus_UPLOAD_FAILURE;
+const int ClientUploadResponse_UploadStatus_UploadStatus_ARRAYSIZE = ClientUploadResponse_UploadStatus_UploadStatus_MAX + 1;
+
+enum ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState {
+  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
+};
+bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_IsValid(int value);
+const ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_MIN = ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_UNKNOWN;
+const ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_MAX = ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_UNTRUSTED_UNKNOWN_VALUE;
+const int ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_ARRAYSIZE = ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_MAX + 1;
+
+enum ClientIncidentReport_IncidentData_ResourceRequestIncident_Type {
+  ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_UNKNOWN = 0,
+  ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_TYPE_PATTERN = 3
+};
+bool ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_IsValid(int value);
+const ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_MIN = ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_UNKNOWN;
+const ClientIncidentReport_IncidentData_ResourceRequestIncident_Type ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_MAX = ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_TYPE_PATTERN;
+const int ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_ARRAYSIZE = ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_MAX + 1;
+
+enum ClientIncidentReport_EnvironmentData_Process_Dll_Feature {
+  ClientIncidentReport_EnvironmentData_Process_Dll_Feature_UNKNOWN = 0,
+  ClientIncidentReport_EnvironmentData_Process_Dll_Feature_LSP = 1
+};
+bool ClientIncidentReport_EnvironmentData_Process_Dll_Feature_IsValid(int value);
+const ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_MIN = ClientIncidentReport_EnvironmentData_Process_Dll_Feature_UNKNOWN;
+const ClientIncidentReport_EnvironmentData_Process_Dll_Feature ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_MAX = ClientIncidentReport_EnvironmentData_Process_Dll_Feature_LSP;
+const int ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_ARRAYSIZE = ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_MAX + 1;
+
+enum ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState {
+  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);
+const ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_MIN = ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_UNKNOWN;
+const ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_MAX = ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_MODULE_STATE_MODIFIED;
+const int ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_ARRAYSIZE = ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_MAX + 1;
+
+enum ClientIncidentReport_EnvironmentData_Process_Channel {
+  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);
+const ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process_Channel_Channel_MIN = ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_UNKNOWN;
+const ClientIncidentReport_EnvironmentData_Process_Channel ClientIncidentReport_EnvironmentData_Process_Channel_Channel_MAX = ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_STABLE;
+const int ClientIncidentReport_EnvironmentData_Process_Channel_Channel_ARRAYSIZE = ClientIncidentReport_EnvironmentData_Process_Channel_Channel_MAX + 1;
+
+enum ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState {
+  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);
+const ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_MIN = ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_UNKNOWN;
+const ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_MAX = ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_TERMINATED;
+const int ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_ARRAYSIZE = ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_MAX + 1;
+
+enum ClientSafeBrowsingReportRequest_ReportType {
+  ClientSafeBrowsingReportRequest_ReportType_UNKNOWN = 0,
+  ClientSafeBrowsingReportRequest_ReportType_URL_PHISHING = 1,
+  ClientSafeBrowsingReportRequest_ReportType_URL_MALWARE = 2,
+  ClientSafeBrowsingReportRequest_ReportType_URL_UNWANTED = 3,
+  ClientSafeBrowsingReportRequest_ReportType_CLIENT_SIDE_PHISHING_URL = 4,
+  ClientSafeBrowsingReportRequest_ReportType_CLIENT_SIDE_MALWARE_URL = 5,
+  ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_RECOVERY = 6,
+  ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_WARNING = 7,
+  ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_BY_API = 10
+};
+bool ClientSafeBrowsingReportRequest_ReportType_IsValid(int value);
+const ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest_ReportType_ReportType_MIN = ClientSafeBrowsingReportRequest_ReportType_UNKNOWN;
+const ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest_ReportType_ReportType_MAX = ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_BY_API;
+const int ClientSafeBrowsingReportRequest_ReportType_ReportType_ARRAYSIZE = ClientSafeBrowsingReportRequest_ReportType_ReportType_MAX + 1;
+
+// ===================================================================
+
+class ChromeUserPopulation : public ::google::protobuf::MessageLite {
+ public:
+  ChromeUserPopulation();
+  virtual ~ChromeUserPopulation();
+
+  ChromeUserPopulation(const ChromeUserPopulation& from);
+
+  inline ChromeUserPopulation& operator=(const ChromeUserPopulation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ChromeUserPopulation& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ChromeUserPopulation* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ChromeUserPopulation* other);
+
+  // implements Message ----------------------------------------------
+
+  ChromeUserPopulation* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ChromeUserPopulation& from);
+  void MergeFrom(const ChromeUserPopulation& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ChromeUserPopulation_UserPopulation UserPopulation;
+  static const UserPopulation UNKNOWN_USER_POPULATION = ChromeUserPopulation_UserPopulation_UNKNOWN_USER_POPULATION;
+  static const UserPopulation SAFE_BROWSING = ChromeUserPopulation_UserPopulation_SAFE_BROWSING;
+  static const UserPopulation EXTENDED_REPORTING = ChromeUserPopulation_UserPopulation_EXTENDED_REPORTING;
+  static inline bool UserPopulation_IsValid(int value) {
+    return ChromeUserPopulation_UserPopulation_IsValid(value);
+  }
+  static const UserPopulation UserPopulation_MIN =
+    ChromeUserPopulation_UserPopulation_UserPopulation_MIN;
+  static const UserPopulation UserPopulation_MAX =
+    ChromeUserPopulation_UserPopulation_UserPopulation_MAX;
+  static const int UserPopulation_ARRAYSIZE =
+    ChromeUserPopulation_UserPopulation_UserPopulation_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional .safe_browsing.ChromeUserPopulation.UserPopulation user_population = 1;
+  inline bool has_user_population() const;
+  inline void clear_user_population();
+  static const int kUserPopulationFieldNumber = 1;
+  inline ::safe_browsing::ChromeUserPopulation_UserPopulation user_population() const;
+  inline void set_user_population(::safe_browsing::ChromeUserPopulation_UserPopulation value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ChromeUserPopulation)
+ private:
+  inline void set_has_user_population();
+  inline void clear_has_user_population();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  int user_population_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChromeUserPopulation* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientPhishingRequest_Feature : public ::google::protobuf::MessageLite {
+ public:
+  ClientPhishingRequest_Feature();
+  virtual ~ClientPhishingRequest_Feature();
+
+  ClientPhishingRequest_Feature(const ClientPhishingRequest_Feature& from);
+
+  inline ClientPhishingRequest_Feature& operator=(const ClientPhishingRequest_Feature& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientPhishingRequest_Feature& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientPhishingRequest_Feature* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientPhishingRequest_Feature* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientPhishingRequest_Feature* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientPhishingRequest_Feature& from);
+  void MergeFrom(const ClientPhishingRequest_Feature& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required string name = 1;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 1;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // required double value = 2;
+  inline bool has_value() const;
+  inline void clear_value();
+  static const int kValueFieldNumber = 2;
+  inline double value() const;
+  inline void set_value(double value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientPhishingRequest.Feature)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_value();
+  inline void clear_has_value();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* name_;
+  double value_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientPhishingRequest_Feature* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientPhishingRequest : public ::google::protobuf::MessageLite {
+ public:
+  ClientPhishingRequest();
+  virtual ~ClientPhishingRequest();
+
+  ClientPhishingRequest(const ClientPhishingRequest& from);
+
+  inline ClientPhishingRequest& operator=(const ClientPhishingRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientPhishingRequest& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientPhishingRequest* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientPhishingRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientPhishingRequest* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientPhishingRequest& from);
+  void MergeFrom(const ClientPhishingRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientPhishingRequest_Feature Feature;
+
+  // accessors -------------------------------------------------------
+
+  // optional string url = 1;
+  inline bool has_url() const;
+  inline void clear_url();
+  static const int kUrlFieldNumber = 1;
+  inline const ::std::string& url() const;
+  inline void set_url(const ::std::string& value);
+  inline void set_url(const char* value);
+  inline void set_url(const char* value, size_t size);
+  inline ::std::string* mutable_url();
+  inline ::std::string* release_url();
+  inline void set_allocated_url(::std::string* url);
+
+  // optional bytes OBSOLETE_hash_prefix = 10;
+  inline bool has_obsolete_hash_prefix() const;
+  inline void clear_obsolete_hash_prefix();
+  static const int kOBSOLETEHashPrefixFieldNumber = 10;
+  inline const ::std::string& obsolete_hash_prefix() const;
+  inline void set_obsolete_hash_prefix(const ::std::string& value);
+  inline void set_obsolete_hash_prefix(const char* value);
+  inline void set_obsolete_hash_prefix(const void* value, size_t size);
+  inline ::std::string* mutable_obsolete_hash_prefix();
+  inline ::std::string* release_obsolete_hash_prefix();
+  inline void set_allocated_obsolete_hash_prefix(::std::string* obsolete_hash_prefix);
+
+  // required float client_score = 2;
+  inline bool has_client_score() const;
+  inline void clear_client_score();
+  static const int kClientScoreFieldNumber = 2;
+  inline float client_score() const;
+  inline void set_client_score(float value);
+
+  // optional bool is_phishing = 4;
+  inline bool has_is_phishing() const;
+  inline void clear_is_phishing();
+  static const int kIsPhishingFieldNumber = 4;
+  inline bool is_phishing() const;
+  inline void set_is_phishing(bool value);
+
+  // repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5;
+  inline int feature_map_size() const;
+  inline void clear_feature_map();
+  static const int kFeatureMapFieldNumber = 5;
+  inline const ::safe_browsing::ClientPhishingRequest_Feature& feature_map(int index) const;
+  inline ::safe_browsing::ClientPhishingRequest_Feature* mutable_feature_map(int index);
+  inline ::safe_browsing::ClientPhishingRequest_Feature* add_feature_map();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >&
+      feature_map() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >*
+      mutable_feature_map();
+
+  // optional int32 model_version = 6;
+  inline bool has_model_version() const;
+  inline void clear_model_version();
+  static const int kModelVersionFieldNumber = 6;
+  inline ::google::protobuf::int32 model_version() const;
+  inline void set_model_version(::google::protobuf::int32 value);
+
+  // repeated .safe_browsing.ClientPhishingRequest.Feature non_model_feature_map = 8;
+  inline int non_model_feature_map_size() const;
+  inline void clear_non_model_feature_map();
+  static const int kNonModelFeatureMapFieldNumber = 8;
+  inline const ::safe_browsing::ClientPhishingRequest_Feature& non_model_feature_map(int index) const;
+  inline ::safe_browsing::ClientPhishingRequest_Feature* mutable_non_model_feature_map(int index);
+  inline ::safe_browsing::ClientPhishingRequest_Feature* add_non_model_feature_map();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >&
+      non_model_feature_map() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >*
+      mutable_non_model_feature_map();
+
+  // optional string OBSOLETE_referrer_url = 9;
+  inline bool has_obsolete_referrer_url() const;
+  inline void clear_obsolete_referrer_url();
+  static const int kOBSOLETEReferrerUrlFieldNumber = 9;
+  inline const ::std::string& obsolete_referrer_url() const;
+  inline void set_obsolete_referrer_url(const ::std::string& value);
+  inline void set_obsolete_referrer_url(const char* value);
+  inline void set_obsolete_referrer_url(const char* value, size_t size);
+  inline ::std::string* mutable_obsolete_referrer_url();
+  inline ::std::string* release_obsolete_referrer_url();
+  inline void set_allocated_obsolete_referrer_url(::std::string* obsolete_referrer_url);
+
+  // repeated uint32 shingle_hashes = 12 [packed = true];
+  inline int shingle_hashes_size() const;
+  inline void clear_shingle_hashes();
+  static const int kShingleHashesFieldNumber = 12;
+  inline ::google::protobuf::uint32 shingle_hashes(int index) const;
+  inline void set_shingle_hashes(int index, ::google::protobuf::uint32 value);
+  inline void add_shingle_hashes(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      shingle_hashes() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_shingle_hashes();
+
+  // optional string model_filename = 13;
+  inline bool has_model_filename() const;
+  inline void clear_model_filename();
+  static const int kModelFilenameFieldNumber = 13;
+  inline const ::std::string& model_filename() const;
+  inline void set_model_filename(const ::std::string& value);
+  inline void set_model_filename(const char* value);
+  inline void set_model_filename(const char* value, size_t size);
+  inline ::std::string* mutable_model_filename();
+  inline ::std::string* release_model_filename();
+  inline void set_allocated_model_filename(::std::string* model_filename);
+
+  // optional .safe_browsing.ChromeUserPopulation population = 14;
+  inline bool has_population() const;
+  inline void clear_population();
+  static const int kPopulationFieldNumber = 14;
+  inline const ::safe_browsing::ChromeUserPopulation& population() const;
+  inline ::safe_browsing::ChromeUserPopulation* mutable_population();
+  inline ::safe_browsing::ChromeUserPopulation* release_population();
+  inline void set_allocated_population(::safe_browsing::ChromeUserPopulation* population);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientPhishingRequest)
+ private:
+  inline void set_has_url();
+  inline void clear_has_url();
+  inline void set_has_obsolete_hash_prefix();
+  inline void clear_has_obsolete_hash_prefix();
+  inline void set_has_client_score();
+  inline void clear_has_client_score();
+  inline void set_has_is_phishing();
+  inline void clear_has_is_phishing();
+  inline void set_has_model_version();
+  inline void clear_has_model_version();
+  inline void set_has_obsolete_referrer_url();
+  inline void clear_has_obsolete_referrer_url();
+  inline void set_has_model_filename();
+  inline void clear_has_model_filename();
+  inline void set_has_population();
+  inline void clear_has_population();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* url_;
+  ::std::string* obsolete_hash_prefix_;
+  float client_score_;
+  bool is_phishing_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature > feature_map_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature > non_model_feature_map_;
+  ::std::string* obsolete_referrer_url_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > shingle_hashes_;
+  mutable int _shingle_hashes_cached_byte_size_;
+  ::std::string* model_filename_;
+  ::safe_browsing::ChromeUserPopulation* population_;
+  ::google::protobuf::int32 model_version_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientPhishingRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientPhishingResponse : public ::google::protobuf::MessageLite {
+ public:
+  ClientPhishingResponse();
+  virtual ~ClientPhishingResponse();
+
+  ClientPhishingResponse(const ClientPhishingResponse& from);
+
+  inline ClientPhishingResponse& operator=(const ClientPhishingResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientPhishingResponse& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientPhishingResponse* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientPhishingResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientPhishingResponse* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientPhishingResponse& from);
+  void MergeFrom(const ClientPhishingResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required bool phishy = 1;
+  inline bool has_phishy() const;
+  inline void clear_phishy();
+  static const int kPhishyFieldNumber = 1;
+  inline bool phishy() const;
+  inline void set_phishy(bool value);
+
+  // repeated string OBSOLETE_whitelist_expression = 2;
+  inline int obsolete_whitelist_expression_size() const;
+  inline void clear_obsolete_whitelist_expression();
+  static const int kOBSOLETEWhitelistExpressionFieldNumber = 2;
+  inline const ::std::string& obsolete_whitelist_expression(int index) const;
+  inline ::std::string* mutable_obsolete_whitelist_expression(int index);
+  inline void set_obsolete_whitelist_expression(int index, const ::std::string& value);
+  inline void set_obsolete_whitelist_expression(int index, const char* value);
+  inline void set_obsolete_whitelist_expression(int index, const char* value, size_t size);
+  inline ::std::string* add_obsolete_whitelist_expression();
+  inline void add_obsolete_whitelist_expression(const ::std::string& value);
+  inline void add_obsolete_whitelist_expression(const char* value);
+  inline void add_obsolete_whitelist_expression(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& obsolete_whitelist_expression() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_obsolete_whitelist_expression();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientPhishingResponse)
+ private:
+  inline void set_has_phishy();
+  inline void clear_has_phishy();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> obsolete_whitelist_expression_;
+  bool phishy_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientPhishingResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientMalwareRequest_UrlInfo : public ::google::protobuf::MessageLite {
+ public:
+  ClientMalwareRequest_UrlInfo();
+  virtual ~ClientMalwareRequest_UrlInfo();
+
+  ClientMalwareRequest_UrlInfo(const ClientMalwareRequest_UrlInfo& from);
+
+  inline ClientMalwareRequest_UrlInfo& operator=(const ClientMalwareRequest_UrlInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientMalwareRequest_UrlInfo& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientMalwareRequest_UrlInfo* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientMalwareRequest_UrlInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientMalwareRequest_UrlInfo* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientMalwareRequest_UrlInfo& from);
+  void MergeFrom(const ClientMalwareRequest_UrlInfo& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required string ip = 1;
+  inline bool has_ip() const;
+  inline void clear_ip();
+  static const int kIpFieldNumber = 1;
+  inline const ::std::string& ip() const;
+  inline void set_ip(const ::std::string& value);
+  inline void set_ip(const char* value);
+  inline void set_ip(const char* value, size_t size);
+  inline ::std::string* mutable_ip();
+  inline ::std::string* release_ip();
+  inline void set_allocated_ip(::std::string* ip);
+
+  // required string url = 2;
+  inline bool has_url() const;
+  inline void clear_url();
+  static const int kUrlFieldNumber = 2;
+  inline const ::std::string& url() const;
+  inline void set_url(const ::std::string& value);
+  inline void set_url(const char* value);
+  inline void set_url(const char* value, size_t size);
+  inline ::std::string* mutable_url();
+  inline ::std::string* release_url();
+  inline void set_allocated_url(::std::string* url);
+
+  // optional string method = 3;
+  inline bool has_method() const;
+  inline void clear_method();
+  static const int kMethodFieldNumber = 3;
+  inline const ::std::string& method() const;
+  inline void set_method(const ::std::string& value);
+  inline void set_method(const char* value);
+  inline void set_method(const char* value, size_t size);
+  inline ::std::string* mutable_method();
+  inline ::std::string* release_method();
+  inline void set_allocated_method(::std::string* method);
+
+  // optional string referrer = 4;
+  inline bool has_referrer() const;
+  inline void clear_referrer();
+  static const int kReferrerFieldNumber = 4;
+  inline const ::std::string& referrer() const;
+  inline void set_referrer(const ::std::string& value);
+  inline void set_referrer(const char* value);
+  inline void set_referrer(const char* value, size_t size);
+  inline ::std::string* mutable_referrer();
+  inline ::std::string* release_referrer();
+  inline void set_allocated_referrer(::std::string* referrer);
+
+  // optional int32 resource_type = 5;
+  inline bool has_resource_type() const;
+  inline void clear_resource_type();
+  static const int kResourceTypeFieldNumber = 5;
+  inline ::google::protobuf::int32 resource_type() const;
+  inline void set_resource_type(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientMalwareRequest.UrlInfo)
+ private:
+  inline void set_has_ip();
+  inline void clear_has_ip();
+  inline void set_has_url();
+  inline void clear_has_url();
+  inline void set_has_method();
+  inline void clear_has_method();
+  inline void set_has_referrer();
+  inline void clear_has_referrer();
+  inline void set_has_resource_type();
+  inline void clear_has_resource_type();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* ip_;
+  ::std::string* url_;
+  ::std::string* method_;
+  ::std::string* referrer_;
+  ::google::protobuf::int32 resource_type_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientMalwareRequest_UrlInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientMalwareRequest : public ::google::protobuf::MessageLite {
+ public:
+  ClientMalwareRequest();
+  virtual ~ClientMalwareRequest();
+
+  ClientMalwareRequest(const ClientMalwareRequest& from);
+
+  inline ClientMalwareRequest& operator=(const ClientMalwareRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientMalwareRequest& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientMalwareRequest* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientMalwareRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientMalwareRequest* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientMalwareRequest& from);
+  void MergeFrom(const ClientMalwareRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientMalwareRequest_UrlInfo UrlInfo;
+
+  // accessors -------------------------------------------------------
+
+  // required string url = 1;
+  inline bool has_url() const;
+  inline void clear_url();
+  static const int kUrlFieldNumber = 1;
+  inline const ::std::string& url() const;
+  inline void set_url(const ::std::string& value);
+  inline void set_url(const char* value);
+  inline void set_url(const char* value, size_t size);
+  inline ::std::string* mutable_url();
+  inline ::std::string* release_url();
+  inline void set_allocated_url(::std::string* url);
+
+  // optional string referrer_url = 4;
+  inline bool has_referrer_url() const;
+  inline void clear_referrer_url();
+  static const int kReferrerUrlFieldNumber = 4;
+  inline const ::std::string& referrer_url() const;
+  inline void set_referrer_url(const ::std::string& value);
+  inline void set_referrer_url(const char* value);
+  inline void set_referrer_url(const char* value, size_t size);
+  inline ::std::string* mutable_referrer_url();
+  inline ::std::string* release_referrer_url();
+  inline void set_allocated_referrer_url(::std::string* referrer_url);
+
+  // repeated .safe_browsing.ClientMalwareRequest.UrlInfo bad_ip_url_info = 7;
+  inline int bad_ip_url_info_size() const;
+  inline void clear_bad_ip_url_info();
+  static const int kBadIpUrlInfoFieldNumber = 7;
+  inline const ::safe_browsing::ClientMalwareRequest_UrlInfo& bad_ip_url_info(int index) const;
+  inline ::safe_browsing::ClientMalwareRequest_UrlInfo* mutable_bad_ip_url_info(int index);
+  inline ::safe_browsing::ClientMalwareRequest_UrlInfo* add_bad_ip_url_info();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_UrlInfo >&
+      bad_ip_url_info() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_UrlInfo >*
+      mutable_bad_ip_url_info();
+
+  // optional .safe_browsing.ChromeUserPopulation population = 9;
+  inline bool has_population() const;
+  inline void clear_population();
+  static const int kPopulationFieldNumber = 9;
+  inline const ::safe_browsing::ChromeUserPopulation& population() const;
+  inline ::safe_browsing::ChromeUserPopulation* mutable_population();
+  inline ::safe_browsing::ChromeUserPopulation* release_population();
+  inline void set_allocated_population(::safe_browsing::ChromeUserPopulation* population);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientMalwareRequest)
+ private:
+  inline void set_has_url();
+  inline void clear_has_url();
+  inline void set_has_referrer_url();
+  inline void clear_has_referrer_url();
+  inline void set_has_population();
+  inline void clear_has_population();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* url_;
+  ::std::string* referrer_url_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_UrlInfo > bad_ip_url_info_;
+  ::safe_browsing::ChromeUserPopulation* population_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientMalwareRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientMalwareResponse : public ::google::protobuf::MessageLite {
+ public:
+  ClientMalwareResponse();
+  virtual ~ClientMalwareResponse();
+
+  ClientMalwareResponse(const ClientMalwareResponse& from);
+
+  inline ClientMalwareResponse& operator=(const ClientMalwareResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientMalwareResponse& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientMalwareResponse* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientMalwareResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientMalwareResponse* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientMalwareResponse& from);
+  void MergeFrom(const ClientMalwareResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required bool blacklist = 1;
+  inline bool has_blacklist() const;
+  inline void clear_blacklist();
+  static const int kBlacklistFieldNumber = 1;
+  inline bool blacklist() const;
+  inline void set_blacklist(bool value);
+
+  // optional string bad_ip = 2;
+  inline bool has_bad_ip() const;
+  inline void clear_bad_ip();
+  static const int kBadIpFieldNumber = 2;
+  inline const ::std::string& bad_ip() const;
+  inline void set_bad_ip(const ::std::string& value);
+  inline void set_bad_ip(const char* value);
+  inline void set_bad_ip(const char* value, size_t size);
+  inline ::std::string* mutable_bad_ip();
+  inline ::std::string* release_bad_ip();
+  inline void set_allocated_bad_ip(::std::string* bad_ip);
+
+  // optional string bad_url = 3;
+  inline bool has_bad_url() const;
+  inline void clear_bad_url();
+  static const int kBadUrlFieldNumber = 3;
+  inline const ::std::string& bad_url() const;
+  inline void set_bad_url(const ::std::string& value);
+  inline void set_bad_url(const char* value);
+  inline void set_bad_url(const char* value, size_t size);
+  inline ::std::string* mutable_bad_url();
+  inline ::std::string* release_bad_url();
+  inline void set_allocated_bad_url(::std::string* bad_url);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientMalwareResponse)
+ private:
+  inline void set_has_blacklist();
+  inline void clear_has_blacklist();
+  inline void set_has_bad_ip();
+  inline void clear_has_bad_ip();
+  inline void set_has_bad_url();
+  inline void clear_has_bad_url();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* bad_ip_;
+  ::std::string* bad_url_;
+  bool blacklist_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientMalwareResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_Digests : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest_Digests();
+  virtual ~ClientDownloadRequest_Digests();
+
+  ClientDownloadRequest_Digests(const ClientDownloadRequest_Digests& from);
+
+  inline ClientDownloadRequest_Digests& operator=(const ClientDownloadRequest_Digests& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest_Digests& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest_Digests* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest_Digests* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_Digests* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest_Digests& from);
+  void MergeFrom(const ClientDownloadRequest_Digests& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bytes sha256 = 1;
+  inline bool has_sha256() const;
+  inline void clear_sha256();
+  static const int kSha256FieldNumber = 1;
+  inline const ::std::string& sha256() const;
+  inline void set_sha256(const ::std::string& value);
+  inline void set_sha256(const char* value);
+  inline void set_sha256(const void* value, size_t size);
+  inline ::std::string* mutable_sha256();
+  inline ::std::string* release_sha256();
+  inline void set_allocated_sha256(::std::string* sha256);
+
+  // optional bytes sha1 = 2;
+  inline bool has_sha1() const;
+  inline void clear_sha1();
+  static const int kSha1FieldNumber = 2;
+  inline const ::std::string& sha1() const;
+  inline void set_sha1(const ::std::string& value);
+  inline void set_sha1(const char* value);
+  inline void set_sha1(const void* value, size_t size);
+  inline ::std::string* mutable_sha1();
+  inline ::std::string* release_sha1();
+  inline void set_allocated_sha1(::std::string* sha1);
+
+  // optional bytes md5 = 3;
+  inline bool has_md5() const;
+  inline void clear_md5();
+  static const int kMd5FieldNumber = 3;
+  inline const ::std::string& md5() const;
+  inline void set_md5(const ::std::string& value);
+  inline void set_md5(const char* value);
+  inline void set_md5(const void* value, size_t size);
+  inline ::std::string* mutable_md5();
+  inline ::std::string* release_md5();
+  inline void set_allocated_md5(::std::string* md5);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.Digests)
+ private:
+  inline void set_has_sha256();
+  inline void clear_has_sha256();
+  inline void set_has_sha1();
+  inline void clear_has_sha1();
+  inline void set_has_md5();
+  inline void clear_has_md5();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* sha256_;
+  ::std::string* sha1_;
+  ::std::string* md5_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest_Digests* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_Resource : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest_Resource();
+  virtual ~ClientDownloadRequest_Resource();
+
+  ClientDownloadRequest_Resource(const ClientDownloadRequest_Resource& from);
+
+  inline ClientDownloadRequest_Resource& operator=(const ClientDownloadRequest_Resource& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest_Resource& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest_Resource* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest_Resource* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_Resource* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest_Resource& from);
+  void MergeFrom(const ClientDownloadRequest_Resource& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required string url = 1;
+  inline bool has_url() const;
+  inline void clear_url();
+  static const int kUrlFieldNumber = 1;
+  inline const ::std::string& url() const;
+  inline void set_url(const ::std::string& value);
+  inline void set_url(const char* value);
+  inline void set_url(const char* value, size_t size);
+  inline ::std::string* mutable_url();
+  inline ::std::string* release_url();
+  inline void set_allocated_url(::std::string* url);
+
+  // required .safe_browsing.ClientDownloadRequest.ResourceType type = 2;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 2;
+  inline ::safe_browsing::ClientDownloadRequest_ResourceType type() const;
+  inline void set_type(::safe_browsing::ClientDownloadRequest_ResourceType value);
+
+  // optional bytes remote_ip = 3;
+  inline bool has_remote_ip() const;
+  inline void clear_remote_ip();
+  static const int kRemoteIpFieldNumber = 3;
+  inline const ::std::string& remote_ip() const;
+  inline void set_remote_ip(const ::std::string& value);
+  inline void set_remote_ip(const char* value);
+  inline void set_remote_ip(const void* value, size_t size);
+  inline ::std::string* mutable_remote_ip();
+  inline ::std::string* release_remote_ip();
+  inline void set_allocated_remote_ip(::std::string* remote_ip);
+
+  // optional string referrer = 4;
+  inline bool has_referrer() const;
+  inline void clear_referrer();
+  static const int kReferrerFieldNumber = 4;
+  inline const ::std::string& referrer() const;
+  inline void set_referrer(const ::std::string& value);
+  inline void set_referrer(const char* value);
+  inline void set_referrer(const char* value, size_t size);
+  inline ::std::string* mutable_referrer();
+  inline ::std::string* release_referrer();
+  inline void set_allocated_referrer(::std::string* referrer);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.Resource)
+ private:
+  inline void set_has_url();
+  inline void clear_has_url();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_remote_ip();
+  inline void clear_has_remote_ip();
+  inline void set_has_referrer();
+  inline void clear_has_referrer();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* url_;
+  ::std::string* remote_ip_;
+  ::std::string* referrer_;
+  int type_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest_Resource* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_CertificateChain_Element : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest_CertificateChain_Element();
+  virtual ~ClientDownloadRequest_CertificateChain_Element();
+
+  ClientDownloadRequest_CertificateChain_Element(const ClientDownloadRequest_CertificateChain_Element& from);
+
+  inline ClientDownloadRequest_CertificateChain_Element& operator=(const ClientDownloadRequest_CertificateChain_Element& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest_CertificateChain_Element& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest_CertificateChain_Element* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest_CertificateChain_Element* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_CertificateChain_Element* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest_CertificateChain_Element& from);
+  void MergeFrom(const ClientDownloadRequest_CertificateChain_Element& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bytes certificate = 1;
+  inline bool has_certificate() const;
+  inline void clear_certificate();
+  static const int kCertificateFieldNumber = 1;
+  inline const ::std::string& certificate() const;
+  inline void set_certificate(const ::std::string& value);
+  inline void set_certificate(const char* value);
+  inline void set_certificate(const void* value, size_t size);
+  inline ::std::string* mutable_certificate();
+  inline ::std::string* release_certificate();
+  inline void set_allocated_certificate(::std::string* certificate);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.CertificateChain.Element)
+ private:
+  inline void set_has_certificate();
+  inline void clear_has_certificate();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* certificate_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest_CertificateChain_Element* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_CertificateChain : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest_CertificateChain();
+  virtual ~ClientDownloadRequest_CertificateChain();
+
+  ClientDownloadRequest_CertificateChain(const ClientDownloadRequest_CertificateChain& from);
+
+  inline ClientDownloadRequest_CertificateChain& operator=(const ClientDownloadRequest_CertificateChain& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest_CertificateChain& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest_CertificateChain* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest_CertificateChain* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_CertificateChain* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest_CertificateChain& from);
+  void MergeFrom(const ClientDownloadRequest_CertificateChain& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientDownloadRequest_CertificateChain_Element Element;
+
+  // accessors -------------------------------------------------------
+
+  // repeated .safe_browsing.ClientDownloadRequest.CertificateChain.Element element = 1;
+  inline int element_size() const;
+  inline void clear_element();
+  static const int kElementFieldNumber = 1;
+  inline const ::safe_browsing::ClientDownloadRequest_CertificateChain_Element& element(int index) const;
+  inline ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* mutable_element(int index);
+  inline ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* add_element();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >&
+      element() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >*
+      mutable_element();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.CertificateChain)
+ private:
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element > element_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest_CertificateChain* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_ExtendedAttr : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest_ExtendedAttr();
+  virtual ~ClientDownloadRequest_ExtendedAttr();
+
+  ClientDownloadRequest_ExtendedAttr(const ClientDownloadRequest_ExtendedAttr& from);
+
+  inline ClientDownloadRequest_ExtendedAttr& operator=(const ClientDownloadRequest_ExtendedAttr& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest_ExtendedAttr& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest_ExtendedAttr* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest_ExtendedAttr* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_ExtendedAttr* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest_ExtendedAttr& from);
+  void MergeFrom(const ClientDownloadRequest_ExtendedAttr& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required string key = 1;
+  inline bool has_key() const;
+  inline void clear_key();
+  static const int kKeyFieldNumber = 1;
+  inline const ::std::string& key() const;
+  inline void set_key(const ::std::string& value);
+  inline void set_key(const char* value);
+  inline void set_key(const char* value, size_t size);
+  inline ::std::string* mutable_key();
+  inline ::std::string* release_key();
+  inline void set_allocated_key(::std::string* key);
+
+  // optional bytes value = 2;
+  inline bool has_value() const;
+  inline void clear_value();
+  static const int kValueFieldNumber = 2;
+  inline const ::std::string& value() const;
+  inline void set_value(const ::std::string& value);
+  inline void set_value(const char* value);
+  inline void set_value(const void* value, size_t size);
+  inline ::std::string* mutable_value();
+  inline ::std::string* release_value();
+  inline void set_allocated_value(::std::string* value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.ExtendedAttr)
+ private:
+  inline void set_has_key();
+  inline void clear_has_key();
+  inline void set_has_value();
+  inline void clear_has_value();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* key_;
+  ::std::string* value_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest_ExtendedAttr* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_SignatureInfo : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest_SignatureInfo();
+  virtual ~ClientDownloadRequest_SignatureInfo();
+
+  ClientDownloadRequest_SignatureInfo(const ClientDownloadRequest_SignatureInfo& from);
+
+  inline ClientDownloadRequest_SignatureInfo& operator=(const ClientDownloadRequest_SignatureInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest_SignatureInfo& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest_SignatureInfo* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest_SignatureInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_SignatureInfo* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest_SignatureInfo& from);
+  void MergeFrom(const ClientDownloadRequest_SignatureInfo& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1;
+  inline int certificate_chain_size() const;
+  inline void clear_certificate_chain();
+  static const int kCertificateChainFieldNumber = 1;
+  inline const ::safe_browsing::ClientDownloadRequest_CertificateChain& certificate_chain(int index) const;
+  inline ::safe_browsing::ClientDownloadRequest_CertificateChain* mutable_certificate_chain(int index);
+  inline ::safe_browsing::ClientDownloadRequest_CertificateChain* add_certificate_chain();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain >&
+      certificate_chain() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain >*
+      mutable_certificate_chain();
+
+  // optional bool trusted = 2;
+  inline bool has_trusted() const;
+  inline void clear_trusted();
+  static const int kTrustedFieldNumber = 2;
+  inline bool trusted() const;
+  inline void set_trusted(bool value);
+
+  // repeated bytes signed_data = 3;
+  inline int signed_data_size() const;
+  inline void clear_signed_data();
+  static const int kSignedDataFieldNumber = 3;
+  inline const ::std::string& signed_data(int index) const;
+  inline ::std::string* mutable_signed_data(int index);
+  inline void set_signed_data(int index, const ::std::string& value);
+  inline void set_signed_data(int index, const char* value);
+  inline void set_signed_data(int index, const void* value, size_t size);
+  inline ::std::string* add_signed_data();
+  inline void add_signed_data(const ::std::string& value);
+  inline void add_signed_data(const char* value);
+  inline void add_signed_data(const void* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& signed_data() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_signed_data();
+
+  // repeated .safe_browsing.ClientDownloadRequest.ExtendedAttr xattr = 4;
+  inline int xattr_size() const;
+  inline void clear_xattr();
+  static const int kXattrFieldNumber = 4;
+  inline const ::safe_browsing::ClientDownloadRequest_ExtendedAttr& xattr(int index) const;
+  inline ::safe_browsing::ClientDownloadRequest_ExtendedAttr* mutable_xattr(int index);
+  inline ::safe_browsing::ClientDownloadRequest_ExtendedAttr* add_xattr();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ExtendedAttr >&
+      xattr() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ExtendedAttr >*
+      mutable_xattr();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.SignatureInfo)
+ private:
+  inline void set_has_trusted();
+  inline void clear_has_trusted();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain > certificate_chain_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> signed_data_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ExtendedAttr > xattr_;
+  bool trusted_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest_SignatureInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_PEImageHeaders_DebugData : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest_PEImageHeaders_DebugData();
+  virtual ~ClientDownloadRequest_PEImageHeaders_DebugData();
+
+  ClientDownloadRequest_PEImageHeaders_DebugData(const ClientDownloadRequest_PEImageHeaders_DebugData& from);
+
+  inline ClientDownloadRequest_PEImageHeaders_DebugData& operator=(const ClientDownloadRequest_PEImageHeaders_DebugData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest_PEImageHeaders_DebugData& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest_PEImageHeaders_DebugData* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest_PEImageHeaders_DebugData* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_PEImageHeaders_DebugData* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest_PEImageHeaders_DebugData& from);
+  void MergeFrom(const ClientDownloadRequest_PEImageHeaders_DebugData& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bytes directory_entry = 1;
+  inline bool has_directory_entry() const;
+  inline void clear_directory_entry();
+  static const int kDirectoryEntryFieldNumber = 1;
+  inline const ::std::string& directory_entry() const;
+  inline void set_directory_entry(const ::std::string& value);
+  inline void set_directory_entry(const char* value);
+  inline void set_directory_entry(const void* value, size_t size);
+  inline ::std::string* mutable_directory_entry();
+  inline ::std::string* release_directory_entry();
+  inline void set_allocated_directory_entry(::std::string* directory_entry);
+
+  // optional bytes raw_data = 2;
+  inline bool has_raw_data() const;
+  inline void clear_raw_data();
+  static const int kRawDataFieldNumber = 2;
+  inline const ::std::string& raw_data() const;
+  inline void set_raw_data(const ::std::string& value);
+  inline void set_raw_data(const char* value);
+  inline void set_raw_data(const void* value, size_t size);
+  inline ::std::string* mutable_raw_data();
+  inline ::std::string* release_raw_data();
+  inline void set_allocated_raw_data(::std::string* raw_data);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData)
+ private:
+  inline void set_has_directory_entry();
+  inline void clear_has_directory_entry();
+  inline void set_has_raw_data();
+  inline void clear_has_raw_data();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* directory_entry_;
+  ::std::string* raw_data_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest_PEImageHeaders_DebugData* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_PEImageHeaders : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest_PEImageHeaders();
+  virtual ~ClientDownloadRequest_PEImageHeaders();
+
+  ClientDownloadRequest_PEImageHeaders(const ClientDownloadRequest_PEImageHeaders& from);
+
+  inline ClientDownloadRequest_PEImageHeaders& operator=(const ClientDownloadRequest_PEImageHeaders& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest_PEImageHeaders& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest_PEImageHeaders* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest_PEImageHeaders* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_PEImageHeaders* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest_PEImageHeaders& from);
+  void MergeFrom(const ClientDownloadRequest_PEImageHeaders& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientDownloadRequest_PEImageHeaders_DebugData DebugData;
+
+  // accessors -------------------------------------------------------
+
+  // optional bytes dos_header = 1;
+  inline bool has_dos_header() const;
+  inline void clear_dos_header();
+  static const int kDosHeaderFieldNumber = 1;
+  inline const ::std::string& dos_header() const;
+  inline void set_dos_header(const ::std::string& value);
+  inline void set_dos_header(const char* value);
+  inline void set_dos_header(const void* value, size_t size);
+  inline ::std::string* mutable_dos_header();
+  inline ::std::string* release_dos_header();
+  inline void set_allocated_dos_header(::std::string* dos_header);
+
+  // optional bytes file_header = 2;
+  inline bool has_file_header() const;
+  inline void clear_file_header();
+  static const int kFileHeaderFieldNumber = 2;
+  inline const ::std::string& file_header() const;
+  inline void set_file_header(const ::std::string& value);
+  inline void set_file_header(const char* value);
+  inline void set_file_header(const void* value, size_t size);
+  inline ::std::string* mutable_file_header();
+  inline ::std::string* release_file_header();
+  inline void set_allocated_file_header(::std::string* file_header);
+
+  // optional bytes optional_headers32 = 3;
+  inline bool has_optional_headers32() const;
+  inline void clear_optional_headers32();
+  static const int kOptionalHeaders32FieldNumber = 3;
+  inline const ::std::string& optional_headers32() const;
+  inline void set_optional_headers32(const ::std::string& value);
+  inline void set_optional_headers32(const char* value);
+  inline void set_optional_headers32(const void* value, size_t size);
+  inline ::std::string* mutable_optional_headers32();
+  inline ::std::string* release_optional_headers32();
+  inline void set_allocated_optional_headers32(::std::string* optional_headers32);
+
+  // optional bytes optional_headers64 = 4;
+  inline bool has_optional_headers64() const;
+  inline void clear_optional_headers64();
+  static const int kOptionalHeaders64FieldNumber = 4;
+  inline const ::std::string& optional_headers64() const;
+  inline void set_optional_headers64(const ::std::string& value);
+  inline void set_optional_headers64(const char* value);
+  inline void set_optional_headers64(const void* value, size_t size);
+  inline ::std::string* mutable_optional_headers64();
+  inline ::std::string* release_optional_headers64();
+  inline void set_allocated_optional_headers64(::std::string* optional_headers64);
+
+  // repeated bytes section_header = 5;
+  inline int section_header_size() const;
+  inline void clear_section_header();
+  static const int kSectionHeaderFieldNumber = 5;
+  inline const ::std::string& section_header(int index) const;
+  inline ::std::string* mutable_section_header(int index);
+  inline void set_section_header(int index, const ::std::string& value);
+  inline void set_section_header(int index, const char* value);
+  inline void set_section_header(int index, const void* value, size_t size);
+  inline ::std::string* add_section_header();
+  inline void add_section_header(const ::std::string& value);
+  inline void add_section_header(const char* value);
+  inline void add_section_header(const void* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& section_header() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_section_header();
+
+  // optional bytes export_section_data = 6;
+  inline bool has_export_section_data() const;
+  inline void clear_export_section_data();
+  static const int kExportSectionDataFieldNumber = 6;
+  inline const ::std::string& export_section_data() const;
+  inline void set_export_section_data(const ::std::string& value);
+  inline void set_export_section_data(const char* value);
+  inline void set_export_section_data(const void* value, size_t size);
+  inline ::std::string* mutable_export_section_data();
+  inline ::std::string* release_export_section_data();
+  inline void set_allocated_export_section_data(::std::string* export_section_data);
+
+  // repeated .safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData debug_data = 7;
+  inline int debug_data_size() const;
+  inline void clear_debug_data();
+  static const int kDebugDataFieldNumber = 7;
+  inline const ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData& debug_data(int index) const;
+  inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData* mutable_debug_data(int index);
+  inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData* add_debug_data();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData >&
+      debug_data() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData >*
+      mutable_debug_data();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.PEImageHeaders)
+ private:
+  inline void set_has_dos_header();
+  inline void clear_has_dos_header();
+  inline void set_has_file_header();
+  inline void clear_has_file_header();
+  inline void set_has_optional_headers32();
+  inline void clear_has_optional_headers32();
+  inline void set_has_optional_headers64();
+  inline void clear_has_optional_headers64();
+  inline void set_has_export_section_data();
+  inline void clear_has_export_section_data();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* dos_header_;
+  ::std::string* file_header_;
+  ::std::string* optional_headers32_;
+  ::std::string* optional_headers64_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> section_header_;
+  ::std::string* export_section_data_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData > debug_data_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest_PEImageHeaders* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_MachOHeaders_LoadCommand : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest_MachOHeaders_LoadCommand();
+  virtual ~ClientDownloadRequest_MachOHeaders_LoadCommand();
+
+  ClientDownloadRequest_MachOHeaders_LoadCommand(const ClientDownloadRequest_MachOHeaders_LoadCommand& from);
+
+  inline ClientDownloadRequest_MachOHeaders_LoadCommand& operator=(const ClientDownloadRequest_MachOHeaders_LoadCommand& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest_MachOHeaders_LoadCommand& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest_MachOHeaders_LoadCommand* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest_MachOHeaders_LoadCommand* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_MachOHeaders_LoadCommand* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest_MachOHeaders_LoadCommand& from);
+  void MergeFrom(const ClientDownloadRequest_MachOHeaders_LoadCommand& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required uint32 command_id = 1;
+  inline bool has_command_id() const;
+  inline void clear_command_id();
+  static const int kCommandIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 command_id() const;
+  inline void set_command_id(::google::protobuf::uint32 value);
+
+  // required bytes command = 2;
+  inline bool has_command() const;
+  inline void clear_command();
+  static const int kCommandFieldNumber = 2;
+  inline const ::std::string& command() const;
+  inline void set_command(const ::std::string& value);
+  inline void set_command(const char* value);
+  inline void set_command(const void* value, size_t size);
+  inline ::std::string* mutable_command();
+  inline ::std::string* release_command();
+  inline void set_allocated_command(::std::string* command);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand)
+ private:
+  inline void set_has_command_id();
+  inline void clear_has_command_id();
+  inline void set_has_command();
+  inline void clear_has_command();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* command_;
+  ::google::protobuf::uint32 command_id_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest_MachOHeaders_LoadCommand* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_MachOHeaders : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest_MachOHeaders();
+  virtual ~ClientDownloadRequest_MachOHeaders();
+
+  ClientDownloadRequest_MachOHeaders(const ClientDownloadRequest_MachOHeaders& from);
+
+  inline ClientDownloadRequest_MachOHeaders& operator=(const ClientDownloadRequest_MachOHeaders& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest_MachOHeaders& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest_MachOHeaders* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest_MachOHeaders* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_MachOHeaders* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest_MachOHeaders& from);
+  void MergeFrom(const ClientDownloadRequest_MachOHeaders& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientDownloadRequest_MachOHeaders_LoadCommand LoadCommand;
+
+  // accessors -------------------------------------------------------
+
+  // required bytes mach_header = 1;
+  inline bool has_mach_header() const;
+  inline void clear_mach_header();
+  static const int kMachHeaderFieldNumber = 1;
+  inline const ::std::string& mach_header() const;
+  inline void set_mach_header(const ::std::string& value);
+  inline void set_mach_header(const char* value);
+  inline void set_mach_header(const void* value, size_t size);
+  inline ::std::string* mutable_mach_header();
+  inline ::std::string* release_mach_header();
+  inline void set_allocated_mach_header(::std::string* mach_header);
+
+  // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand load_commands = 2;
+  inline int load_commands_size() const;
+  inline void clear_load_commands();
+  static const int kLoadCommandsFieldNumber = 2;
+  inline const ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand& load_commands(int index) const;
+  inline ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand* mutable_load_commands(int index);
+  inline ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand* add_load_commands();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand >&
+      load_commands() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand >*
+      mutable_load_commands();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.MachOHeaders)
+ private:
+  inline void set_has_mach_header();
+  inline void clear_has_mach_header();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* mach_header_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand > load_commands_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest_MachOHeaders* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_ImageHeaders : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest_ImageHeaders();
+  virtual ~ClientDownloadRequest_ImageHeaders();
+
+  ClientDownloadRequest_ImageHeaders(const ClientDownloadRequest_ImageHeaders& from);
+
+  inline ClientDownloadRequest_ImageHeaders& operator=(const ClientDownloadRequest_ImageHeaders& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest_ImageHeaders& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest_ImageHeaders* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest_ImageHeaders* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_ImageHeaders* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest_ImageHeaders& from);
+  void MergeFrom(const ClientDownloadRequest_ImageHeaders& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1;
+  inline bool has_pe_headers() const;
+  inline void clear_pe_headers();
+  static const int kPeHeadersFieldNumber = 1;
+  inline const ::safe_browsing::ClientDownloadRequest_PEImageHeaders& pe_headers() const;
+  inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders* mutable_pe_headers();
+  inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders* release_pe_headers();
+  inline void set_allocated_pe_headers(::safe_browsing::ClientDownloadRequest_PEImageHeaders* pe_headers);
+
+  // repeated .safe_browsing.ClientDownloadRequest.MachOHeaders mach_o_headers = 2;
+  inline int mach_o_headers_size() const;
+  inline void clear_mach_o_headers();
+  static const int kMachOHeadersFieldNumber = 2;
+  inline const ::safe_browsing::ClientDownloadRequest_MachOHeaders& mach_o_headers(int index) const;
+  inline ::safe_browsing::ClientDownloadRequest_MachOHeaders* mutable_mach_o_headers(int index);
+  inline ::safe_browsing::ClientDownloadRequest_MachOHeaders* add_mach_o_headers();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders >&
+      mach_o_headers() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders >*
+      mutable_mach_o_headers();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.ImageHeaders)
+ private:
+  inline void set_has_pe_headers();
+  inline void clear_has_pe_headers();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::safe_browsing::ClientDownloadRequest_PEImageHeaders* pe_headers_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_MachOHeaders > mach_o_headers_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest_ImageHeaders* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_ArchivedBinary : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest_ArchivedBinary();
+  virtual ~ClientDownloadRequest_ArchivedBinary();
+
+  ClientDownloadRequest_ArchivedBinary(const ClientDownloadRequest_ArchivedBinary& from);
+
+  inline ClientDownloadRequest_ArchivedBinary& operator=(const ClientDownloadRequest_ArchivedBinary& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest_ArchivedBinary& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest_ArchivedBinary* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest_ArchivedBinary* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_ArchivedBinary* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest_ArchivedBinary& from);
+  void MergeFrom(const ClientDownloadRequest_ArchivedBinary& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string file_basename = 1;
+  inline bool has_file_basename() const;
+  inline void clear_file_basename();
+  static const int kFileBasenameFieldNumber = 1;
+  inline const ::std::string& file_basename() const;
+  inline void set_file_basename(const ::std::string& value);
+  inline void set_file_basename(const char* value);
+  inline void set_file_basename(const char* value, size_t size);
+  inline ::std::string* mutable_file_basename();
+  inline ::std::string* release_file_basename();
+  inline void set_allocated_file_basename(::std::string* file_basename);
+
+  // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 2;
+  inline bool has_download_type() const;
+  inline void clear_download_type();
+  static const int kDownloadTypeFieldNumber = 2;
+  inline ::safe_browsing::ClientDownloadRequest_DownloadType download_type() const;
+  inline void set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value);
+
+  // optional .safe_browsing.ClientDownloadRequest.Digests digests = 3;
+  inline bool has_digests() const;
+  inline void clear_digests();
+  static const int kDigestsFieldNumber = 3;
+  inline const ::safe_browsing::ClientDownloadRequest_Digests& digests() const;
+  inline ::safe_browsing::ClientDownloadRequest_Digests* mutable_digests();
+  inline ::safe_browsing::ClientDownloadRequest_Digests* release_digests();
+  inline void set_allocated_digests(::safe_browsing::ClientDownloadRequest_Digests* digests);
+
+  // optional int64 length = 4;
+  inline bool has_length() const;
+  inline void clear_length();
+  static const int kLengthFieldNumber = 4;
+  inline ::google::protobuf::int64 length() const;
+  inline void set_length(::google::protobuf::int64 value);
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+  inline bool has_signature() const;
+  inline void clear_signature();
+  static const int kSignatureFieldNumber = 5;
+  inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature() const;
+  inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* mutable_signature();
+  inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* release_signature();
+  inline void set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+  inline bool has_image_headers() const;
+  inline void clear_image_headers();
+  static const int kImageHeadersFieldNumber = 6;
+  inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers() const;
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* mutable_image_headers();
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* release_image_headers();
+  inline void set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.ArchivedBinary)
+ private:
+  inline void set_has_file_basename();
+  inline void clear_has_file_basename();
+  inline void set_has_download_type();
+  inline void clear_has_download_type();
+  inline void set_has_digests();
+  inline void clear_has_digests();
+  inline void set_has_length();
+  inline void clear_has_length();
+  inline void set_has_signature();
+  inline void clear_has_signature();
+  inline void set_has_image_headers();
+  inline void clear_has_image_headers();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* file_basename_;
+  ::safe_browsing::ClientDownloadRequest_Digests* digests_;
+  ::google::protobuf::int64 length_;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature_;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers_;
+  int download_type_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest_ArchivedBinary* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest_URLChainEntry : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest_URLChainEntry();
+  virtual ~ClientDownloadRequest_URLChainEntry();
+
+  ClientDownloadRequest_URLChainEntry(const ClientDownloadRequest_URLChainEntry& from);
+
+  inline ClientDownloadRequest_URLChainEntry& operator=(const ClientDownloadRequest_URLChainEntry& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest_URLChainEntry& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest_URLChainEntry* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest_URLChainEntry* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest_URLChainEntry* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest_URLChainEntry& from);
+  void MergeFrom(const ClientDownloadRequest_URLChainEntry& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientDownloadRequest_URLChainEntry_URLType URLType;
+  static const URLType DOWNLOAD_URL = ClientDownloadRequest_URLChainEntry_URLType_DOWNLOAD_URL;
+  static const URLType DOWNLOAD_REFERRER = ClientDownloadRequest_URLChainEntry_URLType_DOWNLOAD_REFERRER;
+  static const URLType LANDING_PAGE = ClientDownloadRequest_URLChainEntry_URLType_LANDING_PAGE;
+  static const URLType LANDING_REFERRER = ClientDownloadRequest_URLChainEntry_URLType_LANDING_REFERRER;
+  static const URLType CLIENT_REDIRECT = ClientDownloadRequest_URLChainEntry_URLType_CLIENT_REDIRECT;
+  static const URLType SERVER_REDIRECT = ClientDownloadRequest_URLChainEntry_URLType_SERVER_REDIRECT;
+  static inline bool URLType_IsValid(int value) {
+    return ClientDownloadRequest_URLChainEntry_URLType_IsValid(value);
+  }
+  static const URLType URLType_MIN =
+    ClientDownloadRequest_URLChainEntry_URLType_URLType_MIN;
+  static const URLType URLType_MAX =
+    ClientDownloadRequest_URLChainEntry_URLType_URLType_MAX;
+  static const int URLType_ARRAYSIZE =
+    ClientDownloadRequest_URLChainEntry_URLType_URLType_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional string url = 1;
+  inline bool has_url() const;
+  inline void clear_url();
+  static const int kUrlFieldNumber = 1;
+  inline const ::std::string& url() const;
+  inline void set_url(const ::std::string& value);
+  inline void set_url(const char* value);
+  inline void set_url(const char* value, size_t size);
+  inline ::std::string* mutable_url();
+  inline ::std::string* release_url();
+  inline void set_allocated_url(::std::string* url);
+
+  // optional .safe_browsing.ClientDownloadRequest.URLChainEntry.URLType type = 2;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 2;
+  inline ::safe_browsing::ClientDownloadRequest_URLChainEntry_URLType type() const;
+  inline void set_type(::safe_browsing::ClientDownloadRequest_URLChainEntry_URLType value);
+
+  // optional string ip_address = 3;
+  inline bool has_ip_address() const;
+  inline void clear_ip_address();
+  static const int kIpAddressFieldNumber = 3;
+  inline const ::std::string& ip_address() const;
+  inline void set_ip_address(const ::std::string& value);
+  inline void set_ip_address(const char* value);
+  inline void set_ip_address(const char* value, size_t size);
+  inline ::std::string* mutable_ip_address();
+  inline ::std::string* release_ip_address();
+  inline void set_allocated_ip_address(::std::string* ip_address);
+
+  // optional string referrer = 4;
+  inline bool has_referrer() const;
+  inline void clear_referrer();
+  static const int kReferrerFieldNumber = 4;
+  inline const ::std::string& referrer() const;
+  inline void set_referrer(const ::std::string& value);
+  inline void set_referrer(const char* value);
+  inline void set_referrer(const char* value, size_t size);
+  inline ::std::string* mutable_referrer();
+  inline ::std::string* release_referrer();
+  inline void set_allocated_referrer(::std::string* referrer);
+
+  // optional string main_frame_referrer = 5;
+  inline bool has_main_frame_referrer() const;
+  inline void clear_main_frame_referrer();
+  static const int kMainFrameReferrerFieldNumber = 5;
+  inline const ::std::string& main_frame_referrer() const;
+  inline void set_main_frame_referrer(const ::std::string& value);
+  inline void set_main_frame_referrer(const char* value);
+  inline void set_main_frame_referrer(const char* value, size_t size);
+  inline ::std::string* mutable_main_frame_referrer();
+  inline ::std::string* release_main_frame_referrer();
+  inline void set_allocated_main_frame_referrer(::std::string* main_frame_referrer);
+
+  // optional bool is_retargeting = 6;
+  inline bool has_is_retargeting() const;
+  inline void clear_is_retargeting();
+  static const int kIsRetargetingFieldNumber = 6;
+  inline bool is_retargeting() const;
+  inline void set_is_retargeting(bool value);
+
+  // optional bool is_user_initiated = 7;
+  inline bool has_is_user_initiated() const;
+  inline void clear_is_user_initiated();
+  static const int kIsUserInitiatedFieldNumber = 7;
+  inline bool is_user_initiated() const;
+  inline void set_is_user_initiated(bool value);
+
+  // optional double timestamp_in_millisec = 8;
+  inline bool has_timestamp_in_millisec() const;
+  inline void clear_timestamp_in_millisec();
+  static const int kTimestampInMillisecFieldNumber = 8;
+  inline double timestamp_in_millisec() const;
+  inline void set_timestamp_in_millisec(double value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.URLChainEntry)
+ private:
+  inline void set_has_url();
+  inline void clear_has_url();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_ip_address();
+  inline void clear_has_ip_address();
+  inline void set_has_referrer();
+  inline void clear_has_referrer();
+  inline void set_has_main_frame_referrer();
+  inline void clear_has_main_frame_referrer();
+  inline void set_has_is_retargeting();
+  inline void clear_has_is_retargeting();
+  inline void set_has_is_user_initiated();
+  inline void clear_has_is_user_initiated();
+  inline void set_has_timestamp_in_millisec();
+  inline void clear_has_timestamp_in_millisec();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* url_;
+  ::std::string* ip_address_;
+  ::std::string* referrer_;
+  ::std::string* main_frame_referrer_;
+  int type_;
+  bool is_retargeting_;
+  bool is_user_initiated_;
+  double timestamp_in_millisec_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest_URLChainEntry* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadRequest : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadRequest();
+  virtual ~ClientDownloadRequest();
+
+  ClientDownloadRequest(const ClientDownloadRequest& from);
+
+  inline ClientDownloadRequest& operator=(const ClientDownloadRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadRequest& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadRequest* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadRequest* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadRequest& from);
+  void MergeFrom(const ClientDownloadRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef 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_URLChainEntry URLChainEntry;
+
+  typedef ClientDownloadRequest_ResourceType ResourceType;
+  static const ResourceType DOWNLOAD_URL = ClientDownloadRequest_ResourceType_DOWNLOAD_URL;
+  static const ResourceType DOWNLOAD_REDIRECT = ClientDownloadRequest_ResourceType_DOWNLOAD_REDIRECT;
+  static const ResourceType TAB_URL = ClientDownloadRequest_ResourceType_TAB_URL;
+  static const ResourceType TAB_REDIRECT = ClientDownloadRequest_ResourceType_TAB_REDIRECT;
+  static const ResourceType PPAPI_DOCUMENT = ClientDownloadRequest_ResourceType_PPAPI_DOCUMENT;
+  static const ResourceType PPAPI_PLUGIN = ClientDownloadRequest_ResourceType_PPAPI_PLUGIN;
+  static inline bool ResourceType_IsValid(int value) {
+    return ClientDownloadRequest_ResourceType_IsValid(value);
+  }
+  static const ResourceType ResourceType_MIN =
+    ClientDownloadRequest_ResourceType_ResourceType_MIN;
+  static const ResourceType ResourceType_MAX =
+    ClientDownloadRequest_ResourceType_ResourceType_MAX;
+  static const int ResourceType_ARRAYSIZE =
+    ClientDownloadRequest_ResourceType_ResourceType_ARRAYSIZE;
+
+  typedef ClientDownloadRequest_DownloadType DownloadType;
+  static const DownloadType WIN_EXECUTABLE = ClientDownloadRequest_DownloadType_WIN_EXECUTABLE;
+  static const DownloadType CHROME_EXTENSION = ClientDownloadRequest_DownloadType_CHROME_EXTENSION;
+  static const DownloadType ANDROID_APK = ClientDownloadRequest_DownloadType_ANDROID_APK;
+  static const DownloadType ZIPPED_EXECUTABLE = ClientDownloadRequest_DownloadType_ZIPPED_EXECUTABLE;
+  static const DownloadType MAC_EXECUTABLE = ClientDownloadRequest_DownloadType_MAC_EXECUTABLE;
+  static const DownloadType ZIPPED_ARCHIVE = ClientDownloadRequest_DownloadType_ZIPPED_ARCHIVE;
+  static const DownloadType ARCHIVE = ClientDownloadRequest_DownloadType_ARCHIVE;
+  static const DownloadType INVALID_ZIP = ClientDownloadRequest_DownloadType_INVALID_ZIP;
+  static const DownloadType INVALID_MAC_ARCHIVE = ClientDownloadRequest_DownloadType_INVALID_MAC_ARCHIVE;
+  static const DownloadType PPAPI_SAVE_REQUEST = ClientDownloadRequest_DownloadType_PPAPI_SAVE_REQUEST;
+  static const DownloadType SAMPLED_UNSUPPORTED_FILE = ClientDownloadRequest_DownloadType_SAMPLED_UNSUPPORTED_FILE;
+  static inline bool DownloadType_IsValid(int value) {
+    return ClientDownloadRequest_DownloadType_IsValid(value);
+  }
+  static const DownloadType DownloadType_MIN =
+    ClientDownloadRequest_DownloadType_DownloadType_MIN;
+  static const DownloadType DownloadType_MAX =
+    ClientDownloadRequest_DownloadType_DownloadType_MAX;
+  static const int DownloadType_ARRAYSIZE =
+    ClientDownloadRequest_DownloadType_DownloadType_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // required string url = 1;
+  inline bool has_url() const;
+  inline void clear_url();
+  static const int kUrlFieldNumber = 1;
+  inline const ::std::string& url() const;
+  inline void set_url(const ::std::string& value);
+  inline void set_url(const char* value);
+  inline void set_url(const char* value, size_t size);
+  inline ::std::string* mutable_url();
+  inline ::std::string* release_url();
+  inline void set_allocated_url(::std::string* url);
+
+  // required .safe_browsing.ClientDownloadRequest.Digests digests = 2;
+  inline bool has_digests() const;
+  inline void clear_digests();
+  static const int kDigestsFieldNumber = 2;
+  inline const ::safe_browsing::ClientDownloadRequest_Digests& digests() const;
+  inline ::safe_browsing::ClientDownloadRequest_Digests* mutable_digests();
+  inline ::safe_browsing::ClientDownloadRequest_Digests* release_digests();
+  inline void set_allocated_digests(::safe_browsing::ClientDownloadRequest_Digests* digests);
+
+  // required int64 length = 3;
+  inline bool has_length() const;
+  inline void clear_length();
+  static const int kLengthFieldNumber = 3;
+  inline ::google::protobuf::int64 length() const;
+  inline void set_length(::google::protobuf::int64 value);
+
+  // repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4;
+  inline int resources_size() const;
+  inline void clear_resources();
+  static const int kResourcesFieldNumber = 4;
+  inline const ::safe_browsing::ClientDownloadRequest_Resource& resources(int index) const;
+  inline ::safe_browsing::ClientDownloadRequest_Resource* mutable_resources(int index);
+  inline ::safe_browsing::ClientDownloadRequest_Resource* add_resources();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource >&
+      resources() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource >*
+      mutable_resources();
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+  inline bool has_signature() const;
+  inline void clear_signature();
+  static const int kSignatureFieldNumber = 5;
+  inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature() const;
+  inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* mutable_signature();
+  inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* release_signature();
+  inline void set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+
+  // optional bool user_initiated = 6;
+  inline bool has_user_initiated() const;
+  inline void clear_user_initiated();
+  static const int kUserInitiatedFieldNumber = 6;
+  inline bool user_initiated() const;
+  inline void set_user_initiated(bool value);
+
+  // optional string file_basename = 9;
+  inline bool has_file_basename() const;
+  inline void clear_file_basename();
+  static const int kFileBasenameFieldNumber = 9;
+  inline const ::std::string& file_basename() const;
+  inline void set_file_basename(const ::std::string& value);
+  inline void set_file_basename(const char* value);
+  inline void set_file_basename(const char* value, size_t size);
+  inline ::std::string* mutable_file_basename();
+  inline ::std::string* release_file_basename();
+  inline void set_allocated_file_basename(::std::string* file_basename);
+
+  // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 10 [default = WIN_EXECUTABLE];
+  inline bool has_download_type() const;
+  inline void clear_download_type();
+  static const int kDownloadTypeFieldNumber = 10;
+  inline ::safe_browsing::ClientDownloadRequest_DownloadType download_type() const;
+  inline void set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value);
+
+  // optional string locale = 11;
+  inline bool has_locale() const;
+  inline void clear_locale();
+  static const int kLocaleFieldNumber = 11;
+  inline const ::std::string& locale() const;
+  inline void set_locale(const ::std::string& value);
+  inline void set_locale(const char* value);
+  inline void set_locale(const char* value, size_t size);
+  inline ::std::string* mutable_locale();
+  inline ::std::string* release_locale();
+  inline void set_allocated_locale(::std::string* locale);
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 18;
+  inline bool has_image_headers() const;
+  inline void clear_image_headers();
+  static const int kImageHeadersFieldNumber = 18;
+  inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers() const;
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* mutable_image_headers();
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* release_image_headers();
+  inline void set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+
+  // repeated .safe_browsing.ClientDownloadRequest.ArchivedBinary archived_binary = 22;
+  inline int archived_binary_size() const;
+  inline void clear_archived_binary();
+  static const int kArchivedBinaryFieldNumber = 22;
+  inline const ::safe_browsing::ClientDownloadRequest_ArchivedBinary& archived_binary(int index) const;
+  inline ::safe_browsing::ClientDownloadRequest_ArchivedBinary* mutable_archived_binary(int index);
+  inline ::safe_browsing::ClientDownloadRequest_ArchivedBinary* add_archived_binary();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ArchivedBinary >&
+      archived_binary() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ArchivedBinary >*
+      mutable_archived_binary();
+
+  // optional .safe_browsing.ChromeUserPopulation population = 24;
+  inline bool has_population() const;
+  inline void clear_population();
+  static const int kPopulationFieldNumber = 24;
+  inline const ::safe_browsing::ChromeUserPopulation& population() const;
+  inline ::safe_browsing::ChromeUserPopulation* mutable_population();
+  inline ::safe_browsing::ChromeUserPopulation* release_population();
+  inline void set_allocated_population(::safe_browsing::ChromeUserPopulation* population);
+
+  // optional bool archive_valid = 26;
+  inline bool has_archive_valid() const;
+  inline void clear_archive_valid();
+  static const int kArchiveValidFieldNumber = 26;
+  inline bool archive_valid() const;
+  inline void set_archive_valid(bool value);
+
+  // optional bool skipped_url_whitelist = 28;
+  inline bool has_skipped_url_whitelist() const;
+  inline void clear_skipped_url_whitelist();
+  static const int kSkippedUrlWhitelistFieldNumber = 28;
+  inline bool skipped_url_whitelist() const;
+  inline void set_skipped_url_whitelist(bool value);
+
+  // optional bool skipped_certificate_whitelist = 31;
+  inline bool has_skipped_certificate_whitelist() const;
+  inline void clear_skipped_certificate_whitelist();
+  static const int kSkippedCertificateWhitelistFieldNumber = 31;
+  inline bool skipped_certificate_whitelist() const;
+  inline void set_skipped_certificate_whitelist(bool value);
+
+  // repeated string alternate_extensions = 35;
+  inline int alternate_extensions_size() const;
+  inline void clear_alternate_extensions();
+  static const int kAlternateExtensionsFieldNumber = 35;
+  inline const ::std::string& alternate_extensions(int index) const;
+  inline ::std::string* mutable_alternate_extensions(int index);
+  inline void set_alternate_extensions(int index, const ::std::string& value);
+  inline void set_alternate_extensions(int index, const char* value);
+  inline void set_alternate_extensions(int index, const char* value, size_t size);
+  inline ::std::string* add_alternate_extensions();
+  inline void add_alternate_extensions(const ::std::string& value);
+  inline void add_alternate_extensions(const char* value);
+  inline void add_alternate_extensions(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& alternate_extensions() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_alternate_extensions();
+
+  // repeated .safe_browsing.ClientDownloadRequest.URLChainEntry url_chain = 36;
+  inline int url_chain_size() const;
+  inline void clear_url_chain();
+  static const int kUrlChainFieldNumber = 36;
+  inline const ::safe_browsing::ClientDownloadRequest_URLChainEntry& url_chain(int index) const;
+  inline ::safe_browsing::ClientDownloadRequest_URLChainEntry* mutable_url_chain(int index);
+  inline ::safe_browsing::ClientDownloadRequest_URLChainEntry* add_url_chain();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_URLChainEntry >&
+      url_chain() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_URLChainEntry >*
+      mutable_url_chain();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest)
+ private:
+  inline void set_has_url();
+  inline void clear_has_url();
+  inline void set_has_digests();
+  inline void clear_has_digests();
+  inline void set_has_length();
+  inline void clear_has_length();
+  inline void set_has_signature();
+  inline void clear_has_signature();
+  inline void set_has_user_initiated();
+  inline void clear_has_user_initiated();
+  inline void set_has_file_basename();
+  inline void clear_has_file_basename();
+  inline void set_has_download_type();
+  inline void clear_has_download_type();
+  inline void set_has_locale();
+  inline void clear_has_locale();
+  inline void set_has_image_headers();
+  inline void clear_has_image_headers();
+  inline void set_has_population();
+  inline void clear_has_population();
+  inline void set_has_archive_valid();
+  inline void clear_has_archive_valid();
+  inline void set_has_skipped_url_whitelist();
+  inline void clear_has_skipped_url_whitelist();
+  inline void set_has_skipped_certificate_whitelist();
+  inline void clear_has_skipped_certificate_whitelist();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* url_;
+  ::safe_browsing::ClientDownloadRequest_Digests* digests_;
+  ::google::protobuf::int64 length_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource > resources_;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature_;
+  ::std::string* file_basename_;
+  ::std::string* locale_;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ArchivedBinary > archived_binary_;
+  int download_type_;
+  bool user_initiated_;
+  bool archive_valid_;
+  bool skipped_url_whitelist_;
+  bool skipped_certificate_whitelist_;
+  ::safe_browsing::ChromeUserPopulation* population_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> alternate_extensions_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_URLChainEntry > url_chain_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadResponse_MoreInfo : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadResponse_MoreInfo();
+  virtual ~ClientDownloadResponse_MoreInfo();
+
+  ClientDownloadResponse_MoreInfo(const ClientDownloadResponse_MoreInfo& from);
+
+  inline ClientDownloadResponse_MoreInfo& operator=(const ClientDownloadResponse_MoreInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadResponse_MoreInfo& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadResponse_MoreInfo* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadResponse_MoreInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadResponse_MoreInfo* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadResponse_MoreInfo& from);
+  void MergeFrom(const ClientDownloadResponse_MoreInfo& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string description = 1;
+  inline bool has_description() const;
+  inline void clear_description();
+  static const int kDescriptionFieldNumber = 1;
+  inline const ::std::string& description() const;
+  inline void set_description(const ::std::string& value);
+  inline void set_description(const char* value);
+  inline void set_description(const char* value, size_t size);
+  inline ::std::string* mutable_description();
+  inline ::std::string* release_description();
+  inline void set_allocated_description(::std::string* description);
+
+  // optional string url = 2;
+  inline bool has_url() const;
+  inline void clear_url();
+  static const int kUrlFieldNumber = 2;
+  inline const ::std::string& url() const;
+  inline void set_url(const ::std::string& value);
+  inline void set_url(const char* value);
+  inline void set_url(const char* value, size_t size);
+  inline ::std::string* mutable_url();
+  inline ::std::string* release_url();
+  inline void set_allocated_url(::std::string* url);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadResponse.MoreInfo)
+ private:
+  inline void set_has_description();
+  inline void clear_has_description();
+  inline void set_has_url();
+  inline void clear_has_url();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* description_;
+  ::std::string* url_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadResponse_MoreInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadResponse : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadResponse();
+  virtual ~ClientDownloadResponse();
+
+  ClientDownloadResponse(const ClientDownloadResponse& from);
+
+  inline ClientDownloadResponse& operator=(const ClientDownloadResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadResponse& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadResponse* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadResponse* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadResponse& from);
+  void MergeFrom(const ClientDownloadResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientDownloadResponse_MoreInfo MoreInfo;
+
+  typedef ClientDownloadResponse_Verdict Verdict;
+  static const Verdict SAFE = ClientDownloadResponse_Verdict_SAFE;
+  static const Verdict DANGEROUS = ClientDownloadResponse_Verdict_DANGEROUS;
+  static const Verdict UNCOMMON = ClientDownloadResponse_Verdict_UNCOMMON;
+  static const Verdict POTENTIALLY_UNWANTED = ClientDownloadResponse_Verdict_POTENTIALLY_UNWANTED;
+  static const Verdict DANGEROUS_HOST = ClientDownloadResponse_Verdict_DANGEROUS_HOST;
+  static const Verdict UNKNOWN = ClientDownloadResponse_Verdict_UNKNOWN;
+  static inline bool Verdict_IsValid(int value) {
+    return ClientDownloadResponse_Verdict_IsValid(value);
+  }
+  static const Verdict Verdict_MIN =
+    ClientDownloadResponse_Verdict_Verdict_MIN;
+  static const Verdict Verdict_MAX =
+    ClientDownloadResponse_Verdict_Verdict_MAX;
+  static const int Verdict_ARRAYSIZE =
+    ClientDownloadResponse_Verdict_Verdict_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional .safe_browsing.ClientDownloadResponse.Verdict verdict = 1 [default = SAFE];
+  inline bool has_verdict() const;
+  inline void clear_verdict();
+  static const int kVerdictFieldNumber = 1;
+  inline ::safe_browsing::ClientDownloadResponse_Verdict verdict() const;
+  inline void set_verdict(::safe_browsing::ClientDownloadResponse_Verdict value);
+
+  // optional .safe_browsing.ClientDownloadResponse.MoreInfo more_info = 2;
+  inline bool has_more_info() const;
+  inline void clear_more_info();
+  static const int kMoreInfoFieldNumber = 2;
+  inline const ::safe_browsing::ClientDownloadResponse_MoreInfo& more_info() const;
+  inline ::safe_browsing::ClientDownloadResponse_MoreInfo* mutable_more_info();
+  inline ::safe_browsing::ClientDownloadResponse_MoreInfo* release_more_info();
+  inline void set_allocated_more_info(::safe_browsing::ClientDownloadResponse_MoreInfo* more_info);
+
+  // optional bytes token = 3;
+  inline bool has_token() const;
+  inline void clear_token();
+  static const int kTokenFieldNumber = 3;
+  inline const ::std::string& token() const;
+  inline void set_token(const ::std::string& value);
+  inline void set_token(const char* value);
+  inline void set_token(const void* value, size_t size);
+  inline ::std::string* mutable_token();
+  inline ::std::string* release_token();
+  inline void set_allocated_token(::std::string* token);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadResponse)
+ private:
+  inline void set_has_verdict();
+  inline void clear_has_verdict();
+  inline void set_has_more_info();
+  inline void clear_has_more_info();
+  inline void set_has_token();
+  inline void clear_has_token();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::safe_browsing::ClientDownloadResponse_MoreInfo* more_info_;
+  ::std::string* token_;
+  int verdict_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadReport_UserInformation : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadReport_UserInformation();
+  virtual ~ClientDownloadReport_UserInformation();
+
+  ClientDownloadReport_UserInformation(const ClientDownloadReport_UserInformation& from);
+
+  inline ClientDownloadReport_UserInformation& operator=(const ClientDownloadReport_UserInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadReport_UserInformation& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadReport_UserInformation* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadReport_UserInformation* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadReport_UserInformation* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadReport_UserInformation& from);
+  void MergeFrom(const ClientDownloadReport_UserInformation& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string email = 1;
+  inline bool has_email() const;
+  inline void clear_email();
+  static const int kEmailFieldNumber = 1;
+  inline const ::std::string& email() const;
+  inline void set_email(const ::std::string& value);
+  inline void set_email(const char* value);
+  inline void set_email(const char* value, size_t size);
+  inline ::std::string* mutable_email();
+  inline ::std::string* release_email();
+  inline void set_allocated_email(::std::string* email);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadReport.UserInformation)
+ private:
+  inline void set_has_email();
+  inline void clear_has_email();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* email_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadReport_UserInformation* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientDownloadReport : public ::google::protobuf::MessageLite {
+ public:
+  ClientDownloadReport();
+  virtual ~ClientDownloadReport();
+
+  ClientDownloadReport(const ClientDownloadReport& from);
+
+  inline ClientDownloadReport& operator=(const ClientDownloadReport& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientDownloadReport& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientDownloadReport* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientDownloadReport* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientDownloadReport* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientDownloadReport& from);
+  void MergeFrom(const ClientDownloadReport& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientDownloadReport_UserInformation UserInformation;
+
+  typedef ClientDownloadReport_Reason Reason;
+  static const Reason SHARE = ClientDownloadReport_Reason_SHARE;
+  static const Reason FALSE_POSITIVE = ClientDownloadReport_Reason_FALSE_POSITIVE;
+  static const Reason APPEAL = ClientDownloadReport_Reason_APPEAL;
+  static inline bool Reason_IsValid(int value) {
+    return ClientDownloadReport_Reason_IsValid(value);
+  }
+  static const Reason Reason_MIN =
+    ClientDownloadReport_Reason_Reason_MIN;
+  static const Reason Reason_MAX =
+    ClientDownloadReport_Reason_Reason_MAX;
+  static const int Reason_ARRAYSIZE =
+    ClientDownloadReport_Reason_Reason_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional .safe_browsing.ClientDownloadReport.Reason reason = 1;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 1;
+  inline ::safe_browsing::ClientDownloadReport_Reason reason() const;
+  inline void set_reason(::safe_browsing::ClientDownloadReport_Reason value);
+
+  // optional .safe_browsing.ClientDownloadRequest download_request = 2;
+  inline bool has_download_request() const;
+  inline void clear_download_request();
+  static const int kDownloadRequestFieldNumber = 2;
+  inline const ::safe_browsing::ClientDownloadRequest& download_request() const;
+  inline ::safe_browsing::ClientDownloadRequest* mutable_download_request();
+  inline ::safe_browsing::ClientDownloadRequest* release_download_request();
+  inline void set_allocated_download_request(::safe_browsing::ClientDownloadRequest* download_request);
+
+  // optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3;
+  inline bool has_user_information() const;
+  inline void clear_user_information();
+  static const int kUserInformationFieldNumber = 3;
+  inline const ::safe_browsing::ClientDownloadReport_UserInformation& user_information() const;
+  inline ::safe_browsing::ClientDownloadReport_UserInformation* mutable_user_information();
+  inline ::safe_browsing::ClientDownloadReport_UserInformation* release_user_information();
+  inline void set_allocated_user_information(::safe_browsing::ClientDownloadReport_UserInformation* user_information);
+
+  // optional bytes comment = 4;
+  inline bool has_comment() const;
+  inline void clear_comment();
+  static const int kCommentFieldNumber = 4;
+  inline const ::std::string& comment() const;
+  inline void set_comment(const ::std::string& value);
+  inline void set_comment(const char* value);
+  inline void set_comment(const void* value, size_t size);
+  inline ::std::string* mutable_comment();
+  inline ::std::string* release_comment();
+  inline void set_allocated_comment(::std::string* comment);
+
+  // optional .safe_browsing.ClientDownloadResponse download_response = 5;
+  inline bool has_download_response() const;
+  inline void clear_download_response();
+  static const int kDownloadResponseFieldNumber = 5;
+  inline const ::safe_browsing::ClientDownloadResponse& download_response() const;
+  inline ::safe_browsing::ClientDownloadResponse* mutable_download_response();
+  inline ::safe_browsing::ClientDownloadResponse* release_download_response();
+  inline void set_allocated_download_response(::safe_browsing::ClientDownloadResponse* download_response);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadReport)
+ private:
+  inline void set_has_reason();
+  inline void clear_has_reason();
+  inline void set_has_download_request();
+  inline void clear_has_download_request();
+  inline void set_has_user_information();
+  inline void clear_has_user_information();
+  inline void set_has_comment();
+  inline void clear_has_comment();
+  inline void set_has_download_response();
+  inline void clear_has_download_response();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::safe_browsing::ClientDownloadRequest* download_request_;
+  ::safe_browsing::ClientDownloadReport_UserInformation* user_information_;
+  ::std::string* comment_;
+  ::safe_browsing::ClientDownloadResponse* download_response_;
+  int reason_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientDownloadReport* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientUploadResponse : public ::google::protobuf::MessageLite {
+ public:
+  ClientUploadResponse();
+  virtual ~ClientUploadResponse();
+
+  ClientUploadResponse(const ClientUploadResponse& from);
+
+  inline ClientUploadResponse& operator=(const ClientUploadResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientUploadResponse& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientUploadResponse* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientUploadResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientUploadResponse* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientUploadResponse& from);
+  void MergeFrom(const ClientUploadResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientUploadResponse_UploadStatus UploadStatus;
+  static const UploadStatus SUCCESS = ClientUploadResponse_UploadStatus_SUCCESS;
+  static const UploadStatus UPLOAD_FAILURE = ClientUploadResponse_UploadStatus_UPLOAD_FAILURE;
+  static inline bool UploadStatus_IsValid(int value) {
+    return ClientUploadResponse_UploadStatus_IsValid(value);
+  }
+  static const UploadStatus UploadStatus_MIN =
+    ClientUploadResponse_UploadStatus_UploadStatus_MIN;
+  static const UploadStatus UploadStatus_MAX =
+    ClientUploadResponse_UploadStatus_UploadStatus_MAX;
+  static const int UploadStatus_ARRAYSIZE =
+    ClientUploadResponse_UploadStatus_UploadStatus_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1;
+  inline bool has_status() const;
+  inline void clear_status();
+  static const int kStatusFieldNumber = 1;
+  inline ::safe_browsing::ClientUploadResponse_UploadStatus status() const;
+  inline void set_status(::safe_browsing::ClientUploadResponse_UploadStatus value);
+
+  // optional string permalink = 2;
+  inline bool has_permalink() const;
+  inline void clear_permalink();
+  static const int kPermalinkFieldNumber = 2;
+  inline const ::std::string& permalink() const;
+  inline void set_permalink(const ::std::string& value);
+  inline void set_permalink(const char* value);
+  inline void set_permalink(const char* value, size_t size);
+  inline ::std::string* mutable_permalink();
+  inline ::std::string* release_permalink();
+  inline void set_allocated_permalink(::std::string* permalink);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientUploadResponse)
+ private:
+  inline void set_has_status();
+  inline void clear_has_status();
+  inline void set_has_permalink();
+  inline void clear_has_permalink();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* permalink_;
+  int status_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientUploadResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_IncidentData_TrackedPreferenceIncident : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident();
+  virtual ~ClientIncidentReport_IncidentData_TrackedPreferenceIncident();
+
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from);
+
+  inline ClientIncidentReport_IncidentData_TrackedPreferenceIncident& operator=(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_IncidentData_TrackedPreferenceIncident* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_IncidentData_TrackedPreferenceIncident* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_IncidentData_TrackedPreferenceIncident* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from);
+  void MergeFrom(const ClientIncidentReport_IncidentData_TrackedPreferenceIncident& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState ValueState;
+  static const ValueState UNKNOWN = ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_UNKNOWN;
+  static const ValueState CLEARED = ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_CLEARED;
+  static const ValueState WEAK_LEGACY_OBSOLETE = ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_WEAK_LEGACY_OBSOLETE;
+  static const ValueState CHANGED = ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_CHANGED;
+  static const ValueState UNTRUSTED_UNKNOWN_VALUE = ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_UNTRUSTED_UNKNOWN_VALUE;
+  static inline bool ValueState_IsValid(int value) {
+    return ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_IsValid(value);
+  }
+  static const ValueState ValueState_MIN =
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_MIN;
+  static const ValueState ValueState_MAX =
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_MAX;
+  static const int ValueState_ARRAYSIZE =
+    ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_ValueState_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional string path = 1;
+  inline bool has_path() const;
+  inline void clear_path();
+  static const int kPathFieldNumber = 1;
+  inline const ::std::string& path() const;
+  inline void set_path(const ::std::string& value);
+  inline void set_path(const char* value);
+  inline void set_path(const char* value, size_t size);
+  inline ::std::string* mutable_path();
+  inline ::std::string* release_path();
+  inline void set_allocated_path(::std::string* path);
+
+  // optional string atomic_value = 2;
+  inline bool has_atomic_value() const;
+  inline void clear_atomic_value();
+  static const int kAtomicValueFieldNumber = 2;
+  inline const ::std::string& atomic_value() const;
+  inline void set_atomic_value(const ::std::string& value);
+  inline void set_atomic_value(const char* value);
+  inline void set_atomic_value(const char* value, size_t size);
+  inline ::std::string* mutable_atomic_value();
+  inline ::std::string* release_atomic_value();
+  inline void set_allocated_atomic_value(::std::string* atomic_value);
+
+  // repeated string split_key = 3;
+  inline int split_key_size() const;
+  inline void clear_split_key();
+  static const int kSplitKeyFieldNumber = 3;
+  inline const ::std::string& split_key(int index) const;
+  inline ::std::string* mutable_split_key(int index);
+  inline void set_split_key(int index, const ::std::string& value);
+  inline void set_split_key(int index, const char* value);
+  inline void set_split_key(int index, const char* value, size_t size);
+  inline ::std::string* add_split_key();
+  inline void add_split_key(const ::std::string& value);
+  inline void add_split_key(const char* value);
+  inline void add_split_key(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& split_key() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_split_key();
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.ValueState value_state = 4;
+  inline bool has_value_state() const;
+  inline void clear_value_state();
+  static const int kValueStateFieldNumber = 4;
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState value_state() const;
+  inline void set_value_state(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident)
+ private:
+  inline void set_has_path();
+  inline void clear_has_path();
+  inline void set_has_atomic_value();
+  inline void clear_has_atomic_value();
+  inline void set_has_value_state();
+  inline void clear_has_value_state();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* path_;
+  ::std::string* atomic_value_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> split_key_;
+  int value_state_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_IncidentData_TrackedPreferenceIncident* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile();
+  virtual ~ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile();
+
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from);
+
+  inline ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& operator=(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from);
+  void MergeFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string relative_path = 1;
+  inline bool has_relative_path() const;
+  inline void clear_relative_path();
+  static const int kRelativePathFieldNumber = 1;
+  inline const ::std::string& relative_path() const;
+  inline void set_relative_path(const ::std::string& value);
+  inline void set_relative_path(const char* value);
+  inline void set_relative_path(const char* value, size_t size);
+  inline ::std::string* mutable_relative_path();
+  inline ::std::string* release_relative_path();
+  inline void set_allocated_relative_path(::std::string* relative_path);
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+  inline bool has_signature() const;
+  inline void clear_signature();
+  static const int kSignatureFieldNumber = 2;
+  inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature() const;
+  inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* mutable_signature();
+  inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* release_signature();
+  inline void set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+  inline bool has_image_headers() const;
+  inline void clear_image_headers();
+  static const int kImageHeadersFieldNumber = 3;
+  inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers() const;
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* mutable_image_headers();
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* release_image_headers();
+  inline void set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile)
+ private:
+  inline void set_has_relative_path();
+  inline void clear_has_relative_path();
+  inline void set_has_signature();
+  inline void clear_has_signature();
+  inline void set_has_image_headers();
+  inline void clear_has_image_headers();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* relative_path_;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature_;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_IncidentData_BinaryIntegrityIncident : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident();
+  virtual ~ClientIncidentReport_IncidentData_BinaryIntegrityIncident();
+
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from);
+
+  inline ClientIncidentReport_IncidentData_BinaryIntegrityIncident& operator=(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_IncidentData_BinaryIntegrityIncident* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_IncidentData_BinaryIntegrityIncident* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_IncidentData_BinaryIntegrityIncident* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from);
+  void MergeFrom(const ClientIncidentReport_IncidentData_BinaryIntegrityIncident& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile ContainedFile;
+
+  // accessors -------------------------------------------------------
+
+  // optional string file_basename = 1;
+  inline bool has_file_basename() const;
+  inline void clear_file_basename();
+  static const int kFileBasenameFieldNumber = 1;
+  inline const ::std::string& file_basename() const;
+  inline void set_file_basename(const ::std::string& value);
+  inline void set_file_basename(const char* value);
+  inline void set_file_basename(const char* value, size_t size);
+  inline ::std::string* mutable_file_basename();
+  inline ::std::string* release_file_basename();
+  inline void set_allocated_file_basename(::std::string* file_basename);
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 2;
+  inline bool has_signature() const;
+  inline void clear_signature();
+  static const int kSignatureFieldNumber = 2;
+  inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature() const;
+  inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* mutable_signature();
+  inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* release_signature();
+  inline void set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 3;
+  inline bool has_image_headers() const;
+  inline void clear_image_headers();
+  static const int kImageHeadersFieldNumber = 3;
+  inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers() const;
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* mutable_image_headers();
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* release_image_headers();
+  inline void set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+
+  // optional int32 sec_error = 4;
+  inline bool has_sec_error() const;
+  inline void clear_sec_error();
+  static const int kSecErrorFieldNumber = 4;
+  inline ::google::protobuf::int32 sec_error() const;
+  inline void set_sec_error(::google::protobuf::int32 value);
+
+  // repeated .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile contained_file = 5;
+  inline int contained_file_size() const;
+  inline void clear_contained_file();
+  static const int kContainedFileFieldNumber = 5;
+  inline const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile& contained_file(int index) const;
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* mutable_contained_file(int index);
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile* add_contained_file();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile >&
+      contained_file() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile >*
+      mutable_contained_file();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident)
+ private:
+  inline void set_has_file_basename();
+  inline void clear_has_file_basename();
+  inline void set_has_signature();
+  inline void clear_has_signature();
+  inline void set_has_image_headers();
+  inline void clear_has_image_headers();
+  inline void set_has_sec_error();
+  inline void clear_has_sec_error();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* file_basename_;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature_;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile > contained_file_;
+  ::google::protobuf::int32 sec_error_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_IncidentData_BinaryIntegrityIncident* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_IncidentData_BlacklistLoadIncident : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_IncidentData_BlacklistLoadIncident();
+  virtual ~ClientIncidentReport_IncidentData_BlacklistLoadIncident();
+
+  ClientIncidentReport_IncidentData_BlacklistLoadIncident(const ClientIncidentReport_IncidentData_BlacklistLoadIncident& from);
+
+  inline ClientIncidentReport_IncidentData_BlacklistLoadIncident& operator=(const ClientIncidentReport_IncidentData_BlacklistLoadIncident& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_IncidentData_BlacklistLoadIncident& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_IncidentData_BlacklistLoadIncident* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_IncidentData_BlacklistLoadIncident* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_IncidentData_BlacklistLoadIncident* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_IncidentData_BlacklistLoadIncident& from);
+  void MergeFrom(const ClientIncidentReport_IncidentData_BlacklistLoadIncident& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string path = 1;
+  inline bool has_path() const;
+  inline void clear_path();
+  static const int kPathFieldNumber = 1;
+  inline const ::std::string& path() const;
+  inline void set_path(const ::std::string& value);
+  inline void set_path(const char* value);
+  inline void set_path(const char* value, size_t size);
+  inline ::std::string* mutable_path();
+  inline ::std::string* release_path();
+  inline void set_allocated_path(::std::string* path);
+
+  // optional .safe_browsing.ClientDownloadRequest.Digests digest = 2;
+  inline bool has_digest() const;
+  inline void clear_digest();
+  static const int kDigestFieldNumber = 2;
+  inline const ::safe_browsing::ClientDownloadRequest_Digests& digest() const;
+  inline ::safe_browsing::ClientDownloadRequest_Digests* mutable_digest();
+  inline ::safe_browsing::ClientDownloadRequest_Digests* release_digest();
+  inline void set_allocated_digest(::safe_browsing::ClientDownloadRequest_Digests* digest);
+
+  // optional string version = 3;
+  inline bool has_version() const;
+  inline void clear_version();
+  static const int kVersionFieldNumber = 3;
+  inline const ::std::string& version() const;
+  inline void set_version(const ::std::string& value);
+  inline void set_version(const char* value);
+  inline void set_version(const char* value, size_t size);
+  inline ::std::string* mutable_version();
+  inline ::std::string* release_version();
+  inline void set_allocated_version(::std::string* version);
+
+  // optional bool blacklist_initialized = 4;
+  inline bool has_blacklist_initialized() const;
+  inline void clear_blacklist_initialized();
+  static const int kBlacklistInitializedFieldNumber = 4;
+  inline bool blacklist_initialized() const;
+  inline void set_blacklist_initialized(bool value);
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+  inline bool has_signature() const;
+  inline void clear_signature();
+  static const int kSignatureFieldNumber = 5;
+  inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature() const;
+  inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* mutable_signature();
+  inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* release_signature();
+  inline void set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+  inline bool has_image_headers() const;
+  inline void clear_image_headers();
+  static const int kImageHeadersFieldNumber = 6;
+  inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers() const;
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* mutable_image_headers();
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* release_image_headers();
+  inline void set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident)
+ private:
+  inline void set_has_path();
+  inline void clear_has_path();
+  inline void set_has_digest();
+  inline void clear_has_digest();
+  inline void set_has_version();
+  inline void clear_has_version();
+  inline void set_has_blacklist_initialized();
+  inline void clear_has_blacklist_initialized();
+  inline void set_has_signature();
+  inline void clear_has_signature();
+  inline void set_has_image_headers();
+  inline void clear_has_image_headers();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* path_;
+  ::safe_browsing::ClientDownloadRequest_Digests* digest_;
+  ::std::string* version_;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature_;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers_;
+  bool blacklist_initialized_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_IncidentData_BlacklistLoadIncident* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident();
+  virtual ~ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident();
+
+  ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident(const ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident& from);
+
+  inline ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident& operator=(const ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident& from);
+  void MergeFrom(const ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string variations_seed_signature = 1;
+  inline bool has_variations_seed_signature() const;
+  inline void clear_variations_seed_signature();
+  static const int kVariationsSeedSignatureFieldNumber = 1;
+  inline const ::std::string& variations_seed_signature() const;
+  inline void set_variations_seed_signature(const ::std::string& value);
+  inline void set_variations_seed_signature(const char* value);
+  inline void set_variations_seed_signature(const char* value, size_t size);
+  inline ::std::string* mutable_variations_seed_signature();
+  inline ::std::string* release_variations_seed_signature();
+  inline void set_allocated_variations_seed_signature(::std::string* variations_seed_signature);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident)
+ private:
+  inline void set_has_variations_seed_signature();
+  inline void clear_has_variations_seed_signature();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* variations_seed_signature_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_IncidentData_ResourceRequestIncident : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_IncidentData_ResourceRequestIncident();
+  virtual ~ClientIncidentReport_IncidentData_ResourceRequestIncident();
+
+  ClientIncidentReport_IncidentData_ResourceRequestIncident(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from);
+
+  inline ClientIncidentReport_IncidentData_ResourceRequestIncident& operator=(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_IncidentData_ResourceRequestIncident& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_IncidentData_ResourceRequestIncident* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_IncidentData_ResourceRequestIncident* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_IncidentData_ResourceRequestIncident* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from);
+  void MergeFrom(const ClientIncidentReport_IncidentData_ResourceRequestIncident& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_IncidentData_ResourceRequestIncident_Type Type;
+  static const Type UNKNOWN = ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_UNKNOWN;
+  static const Type TYPE_PATTERN = ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_TYPE_PATTERN;
+  static inline bool Type_IsValid(int value) {
+    return ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_IsValid(value);
+  }
+  static const Type Type_MIN =
+    ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_MIN;
+  static const Type Type_MAX =
+    ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_MAX;
+  static const int Type_ARRAYSIZE =
+    ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_Type_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional bytes digest = 1;
+  inline bool has_digest() const;
+  inline void clear_digest();
+  static const int kDigestFieldNumber = 1;
+  inline const ::std::string& digest() const;
+  inline void set_digest(const ::std::string& value);
+  inline void set_digest(const char* value);
+  inline void set_digest(const void* value, size_t size);
+  inline ::std::string* mutable_digest();
+  inline ::std::string* release_digest();
+  inline void set_allocated_digest(::std::string* digest);
+
+  // optional string origin = 2;
+  inline bool has_origin() const;
+  inline void clear_origin();
+  static const int kOriginFieldNumber = 2;
+  inline const ::std::string& origin() const;
+  inline void set_origin(const ::std::string& value);
+  inline void set_origin(const char* value);
+  inline void set_origin(const char* value, size_t size);
+  inline ::std::string* mutable_origin();
+  inline ::std::string* release_origin();
+  inline void set_allocated_origin(::std::string* origin);
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.Type type = 3 [default = UNKNOWN];
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 3;
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type type() const;
+  inline void set_type(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident)
+ private:
+  inline void set_has_digest();
+  inline void clear_has_digest();
+  inline void set_has_origin();
+  inline void clear_has_origin();
+  inline void set_has_type();
+  inline void clear_has_type();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* digest_;
+  ::std::string* origin_;
+  int type_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_IncidentData_ResourceRequestIncident* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_IncidentData_SuspiciousModuleIncident : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_IncidentData_SuspiciousModuleIncident();
+  virtual ~ClientIncidentReport_IncidentData_SuspiciousModuleIncident();
+
+  ClientIncidentReport_IncidentData_SuspiciousModuleIncident(const ClientIncidentReport_IncidentData_SuspiciousModuleIncident& from);
+
+  inline ClientIncidentReport_IncidentData_SuspiciousModuleIncident& operator=(const ClientIncidentReport_IncidentData_SuspiciousModuleIncident& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_IncidentData_SuspiciousModuleIncident& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_IncidentData_SuspiciousModuleIncident* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_IncidentData_SuspiciousModuleIncident* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_IncidentData_SuspiciousModuleIncident* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_IncidentData_SuspiciousModuleIncident& from);
+  void MergeFrom(const ClientIncidentReport_IncidentData_SuspiciousModuleIncident& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string path = 1;
+  inline bool has_path() const;
+  inline void clear_path();
+  static const int kPathFieldNumber = 1;
+  inline const ::std::string& path() const;
+  inline void set_path(const ::std::string& value);
+  inline void set_path(const char* value);
+  inline void set_path(const char* value, size_t size);
+  inline ::std::string* mutable_path();
+  inline ::std::string* release_path();
+  inline void set_allocated_path(::std::string* path);
+
+  // optional .safe_browsing.ClientDownloadRequest.Digests digest = 2;
+  inline bool has_digest() const;
+  inline void clear_digest();
+  static const int kDigestFieldNumber = 2;
+  inline const ::safe_browsing::ClientDownloadRequest_Digests& digest() const;
+  inline ::safe_browsing::ClientDownloadRequest_Digests* mutable_digest();
+  inline ::safe_browsing::ClientDownloadRequest_Digests* release_digest();
+  inline void set_allocated_digest(::safe_browsing::ClientDownloadRequest_Digests* digest);
+
+  // optional string version = 3;
+  inline bool has_version() const;
+  inline void clear_version();
+  static const int kVersionFieldNumber = 3;
+  inline const ::std::string& version() const;
+  inline void set_version(const ::std::string& value);
+  inline void set_version(const char* value);
+  inline void set_version(const char* value, size_t size);
+  inline ::std::string* mutable_version();
+  inline ::std::string* release_version();
+  inline void set_allocated_version(::std::string* version);
+
+  // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 4;
+  inline bool has_signature() const;
+  inline void clear_signature();
+  static const int kSignatureFieldNumber = 4;
+  inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature() const;
+  inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* mutable_signature();
+  inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* release_signature();
+  inline void set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature);
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+  inline bool has_image_headers() const;
+  inline void clear_image_headers();
+  static const int kImageHeadersFieldNumber = 5;
+  inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers() const;
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* mutable_image_headers();
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* release_image_headers();
+  inline void set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident)
+ private:
+  inline void set_has_path();
+  inline void clear_has_path();
+  inline void set_has_digest();
+  inline void clear_has_digest();
+  inline void set_has_version();
+  inline void clear_has_version();
+  inline void set_has_signature();
+  inline void clear_has_signature();
+  inline void set_has_image_headers();
+  inline void clear_has_image_headers();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* path_;
+  ::safe_browsing::ClientDownloadRequest_Digests* digest_;
+  ::std::string* version_;
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature_;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_IncidentData_SuspiciousModuleIncident* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_IncidentData : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_IncidentData();
+  virtual ~ClientIncidentReport_IncidentData();
+
+  ClientIncidentReport_IncidentData(const ClientIncidentReport_IncidentData& from);
+
+  inline ClientIncidentReport_IncidentData& operator=(const ClientIncidentReport_IncidentData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_IncidentData& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_IncidentData* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_IncidentData* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_IncidentData* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_IncidentData& from);
+  void MergeFrom(const ClientIncidentReport_IncidentData& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_IncidentData_TrackedPreferenceIncident TrackedPreferenceIncident;
+  typedef ClientIncidentReport_IncidentData_BinaryIntegrityIncident BinaryIntegrityIncident;
+  typedef ClientIncidentReport_IncidentData_BlacklistLoadIncident BlacklistLoadIncident;
+  typedef ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident VariationsSeedSignatureIncident;
+  typedef ClientIncidentReport_IncidentData_ResourceRequestIncident ResourceRequestIncident;
+  typedef ClientIncidentReport_IncidentData_SuspiciousModuleIncident SuspiciousModuleIncident;
+
+  // accessors -------------------------------------------------------
+
+  // optional int64 incident_time_msec = 1;
+  inline bool has_incident_time_msec() const;
+  inline void clear_incident_time_msec();
+  static const int kIncidentTimeMsecFieldNumber = 1;
+  inline ::google::protobuf::int64 incident_time_msec() const;
+  inline void set_incident_time_msec(::google::protobuf::int64 value);
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident tracked_preference = 2;
+  inline bool has_tracked_preference() const;
+  inline void clear_tracked_preference();
+  static const int kTrackedPreferenceFieldNumber = 2;
+  inline const ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident& tracked_preference() const;
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* mutable_tracked_preference();
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* release_tracked_preference();
+  inline void set_allocated_tracked_preference(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* tracked_preference);
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident binary_integrity = 3;
+  inline bool has_binary_integrity() const;
+  inline void clear_binary_integrity();
+  static const int kBinaryIntegrityFieldNumber = 3;
+  inline const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident& binary_integrity() const;
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* mutable_binary_integrity();
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* release_binary_integrity();
+  inline void set_allocated_binary_integrity(::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* binary_integrity);
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident blacklist_load = 4;
+  inline bool has_blacklist_load() const;
+  inline void clear_blacklist_load();
+  static const int kBlacklistLoadFieldNumber = 4;
+  inline const ::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident& blacklist_load() const;
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident* mutable_blacklist_load();
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident* release_blacklist_load();
+  inline void set_allocated_blacklist_load(::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident* blacklist_load);
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident variations_seed_signature = 6;
+  inline bool has_variations_seed_signature() const;
+  inline void clear_variations_seed_signature();
+  static const int kVariationsSeedSignatureFieldNumber = 6;
+  inline const ::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident& variations_seed_signature() const;
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* mutable_variations_seed_signature();
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* release_variations_seed_signature();
+  inline void set_allocated_variations_seed_signature(::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* variations_seed_signature);
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident resource_request = 7;
+  inline bool has_resource_request() const;
+  inline void clear_resource_request();
+  static const int kResourceRequestFieldNumber = 7;
+  inline const ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident& resource_request() const;
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* mutable_resource_request();
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* release_resource_request();
+  inline void set_allocated_resource_request(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* resource_request);
+
+  // optional .safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident suspicious_module = 8;
+  inline bool has_suspicious_module() const;
+  inline void clear_suspicious_module();
+  static const int kSuspiciousModuleFieldNumber = 8;
+  inline const ::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident& suspicious_module() const;
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident* mutable_suspicious_module();
+  inline ::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident* release_suspicious_module();
+  inline void set_allocated_suspicious_module(::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident* suspicious_module);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.IncidentData)
+ private:
+  inline void set_has_incident_time_msec();
+  inline void clear_has_incident_time_msec();
+  inline void set_has_tracked_preference();
+  inline void clear_has_tracked_preference();
+  inline void set_has_binary_integrity();
+  inline void clear_has_binary_integrity();
+  inline void set_has_blacklist_load();
+  inline void clear_has_blacklist_load();
+  inline void set_has_variations_seed_signature();
+  inline void clear_has_variations_seed_signature();
+  inline void set_has_resource_request();
+  inline void clear_has_resource_request();
+  inline void set_has_suspicious_module();
+  inline void clear_has_suspicious_module();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::int64 incident_time_msec_;
+  ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* tracked_preference_;
+  ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* binary_integrity_;
+  ::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident* blacklist_load_;
+  ::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* variations_seed_signature_;
+  ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* resource_request_;
+  ::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident* suspicious_module_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_IncidentData* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_DownloadDetails : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_DownloadDetails();
+  virtual ~ClientIncidentReport_DownloadDetails();
+
+  ClientIncidentReport_DownloadDetails(const ClientIncidentReport_DownloadDetails& from);
+
+  inline ClientIncidentReport_DownloadDetails& operator=(const ClientIncidentReport_DownloadDetails& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_DownloadDetails& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_DownloadDetails* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_DownloadDetails* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_DownloadDetails* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_DownloadDetails& from);
+  void MergeFrom(const ClientIncidentReport_DownloadDetails& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bytes token = 1;
+  inline bool has_token() const;
+  inline void clear_token();
+  static const int kTokenFieldNumber = 1;
+  inline const ::std::string& token() const;
+  inline void set_token(const ::std::string& value);
+  inline void set_token(const char* value);
+  inline void set_token(const void* value, size_t size);
+  inline ::std::string* mutable_token();
+  inline ::std::string* release_token();
+  inline void set_allocated_token(::std::string* token);
+
+  // optional .safe_browsing.ClientDownloadRequest download = 2;
+  inline bool has_download() const;
+  inline void clear_download();
+  static const int kDownloadFieldNumber = 2;
+  inline const ::safe_browsing::ClientDownloadRequest& download() const;
+  inline ::safe_browsing::ClientDownloadRequest* mutable_download();
+  inline ::safe_browsing::ClientDownloadRequest* release_download();
+  inline void set_allocated_download(::safe_browsing::ClientDownloadRequest* download);
+
+  // optional int64 download_time_msec = 3;
+  inline bool has_download_time_msec() const;
+  inline void clear_download_time_msec();
+  static const int kDownloadTimeMsecFieldNumber = 3;
+  inline ::google::protobuf::int64 download_time_msec() const;
+  inline void set_download_time_msec(::google::protobuf::int64 value);
+
+  // optional int64 open_time_msec = 4;
+  inline bool has_open_time_msec() const;
+  inline void clear_open_time_msec();
+  static const int kOpenTimeMsecFieldNumber = 4;
+  inline ::google::protobuf::int64 open_time_msec() const;
+  inline void set_open_time_msec(::google::protobuf::int64 value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.DownloadDetails)
+ private:
+  inline void set_has_token();
+  inline void clear_has_token();
+  inline void set_has_download();
+  inline void clear_has_download();
+  inline void set_has_download_time_msec();
+  inline void clear_has_download_time_msec();
+  inline void set_has_open_time_msec();
+  inline void clear_has_open_time_msec();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* token_;
+  ::safe_browsing::ClientDownloadRequest* download_;
+  ::google::protobuf::int64 download_time_msec_;
+  ::google::protobuf::int64 open_time_msec_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_DownloadDetails* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_OS_RegistryValue : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_EnvironmentData_OS_RegistryValue();
+  virtual ~ClientIncidentReport_EnvironmentData_OS_RegistryValue();
+
+  ClientIncidentReport_EnvironmentData_OS_RegistryValue(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from);
+
+  inline ClientIncidentReport_EnvironmentData_OS_RegistryValue& operator=(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_EnvironmentData_OS_RegistryValue& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_EnvironmentData_OS_RegistryValue* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_EnvironmentData_OS_RegistryValue* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_OS_RegistryValue* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryValue& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string name = 1;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 1;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional uint32 type = 2;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 2;
+  inline ::google::protobuf::uint32 type() const;
+  inline void set_type(::google::protobuf::uint32 value);
+
+  // optional bytes data = 3;
+  inline bool has_data() const;
+  inline void clear_data();
+  static const int kDataFieldNumber = 3;
+  inline const ::std::string& data() const;
+  inline void set_data(const ::std::string& value);
+  inline void set_data(const char* value);
+  inline void set_data(const void* value, size_t size);
+  inline ::std::string* mutable_data();
+  inline ::std::string* release_data();
+  inline void set_allocated_data(::std::string* data);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_data();
+  inline void clear_has_data();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* name_;
+  ::std::string* data_;
+  ::google::protobuf::uint32 type_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_EnvironmentData_OS_RegistryValue* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_OS_RegistryKey : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_EnvironmentData_OS_RegistryKey();
+  virtual ~ClientIncidentReport_EnvironmentData_OS_RegistryKey();
+
+  ClientIncidentReport_EnvironmentData_OS_RegistryKey(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from);
+
+  inline ClientIncidentReport_EnvironmentData_OS_RegistryKey& operator=(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_EnvironmentData_OS_RegistryKey& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_EnvironmentData_OS_RegistryKey* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_EnvironmentData_OS_RegistryKey* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_OS_RegistryKey* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_OS_RegistryKey& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string name = 1;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 1;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue value = 2;
+  inline int value_size() const;
+  inline void clear_value();
+  static const int kValueFieldNumber = 2;
+  inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue& value(int index) const;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue* mutable_value(int index);
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue* add_value();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue >&
+      value() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue >*
+      mutable_value();
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey key = 3;
+  inline int key_size() const;
+  inline void clear_key();
+  static const int kKeyFieldNumber = 3;
+  inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey& key(int index) const;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* mutable_key(int index);
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* add_key();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >&
+      key() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >*
+      mutable_key();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* name_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryValue > value_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey > key_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_EnvironmentData_OS_RegistryKey* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_OS : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_EnvironmentData_OS();
+  virtual ~ClientIncidentReport_EnvironmentData_OS();
+
+  ClientIncidentReport_EnvironmentData_OS(const ClientIncidentReport_EnvironmentData_OS& from);
+
+  inline ClientIncidentReport_EnvironmentData_OS& operator=(const ClientIncidentReport_EnvironmentData_OS& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_EnvironmentData_OS& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_EnvironmentData_OS* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_EnvironmentData_OS* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_OS* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_OS& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_OS& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_EnvironmentData_OS_RegistryValue RegistryValue;
+  typedef ClientIncidentReport_EnvironmentData_OS_RegistryKey RegistryKey;
+
+  // accessors -------------------------------------------------------
+
+  // optional string os_name = 1;
+  inline bool has_os_name() const;
+  inline void clear_os_name();
+  static const int kOsNameFieldNumber = 1;
+  inline const ::std::string& os_name() const;
+  inline void set_os_name(const ::std::string& value);
+  inline void set_os_name(const char* value);
+  inline void set_os_name(const char* value, size_t size);
+  inline ::std::string* mutable_os_name();
+  inline ::std::string* release_os_name();
+  inline void set_allocated_os_name(::std::string* os_name);
+
+  // optional string os_version = 2;
+  inline bool has_os_version() const;
+  inline void clear_os_version();
+  static const int kOsVersionFieldNumber = 2;
+  inline const ::std::string& os_version() const;
+  inline void set_os_version(const ::std::string& value);
+  inline void set_os_version(const char* value);
+  inline void set_os_version(const char* value, size_t size);
+  inline ::std::string* mutable_os_version();
+  inline ::std::string* release_os_version();
+  inline void set_allocated_os_version(::std::string* os_version);
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey registry_key = 3;
+  inline int registry_key_size() const;
+  inline void clear_registry_key();
+  static const int kRegistryKeyFieldNumber = 3;
+  inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey& registry_key(int index) const;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* mutable_registry_key(int index);
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey* add_registry_key();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >&
+      registry_key() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey >*
+      mutable_registry_key();
+
+  // optional bool is_enrolled_to_domain = 4;
+  inline bool has_is_enrolled_to_domain() const;
+  inline void clear_is_enrolled_to_domain();
+  static const int kIsEnrolledToDomainFieldNumber = 4;
+  inline bool is_enrolled_to_domain() const;
+  inline void set_is_enrolled_to_domain(bool value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.OS)
+ private:
+  inline void set_has_os_name();
+  inline void clear_has_os_name();
+  inline void set_has_os_version();
+  inline void clear_has_os_version();
+  inline void set_has_is_enrolled_to_domain();
+  inline void clear_has_is_enrolled_to_domain();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* os_name_;
+  ::std::string* os_version_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_OS_RegistryKey > registry_key_;
+  bool is_enrolled_to_domain_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_EnvironmentData_OS* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Machine : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_EnvironmentData_Machine();
+  virtual ~ClientIncidentReport_EnvironmentData_Machine();
+
+  ClientIncidentReport_EnvironmentData_Machine(const ClientIncidentReport_EnvironmentData_Machine& from);
+
+  inline ClientIncidentReport_EnvironmentData_Machine& operator=(const ClientIncidentReport_EnvironmentData_Machine& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Machine& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_EnvironmentData_Machine* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_EnvironmentData_Machine* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Machine* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Machine& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Machine& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string cpu_architecture = 1;
+  inline bool has_cpu_architecture() const;
+  inline void clear_cpu_architecture();
+  static const int kCpuArchitectureFieldNumber = 1;
+  inline const ::std::string& cpu_architecture() const;
+  inline void set_cpu_architecture(const ::std::string& value);
+  inline void set_cpu_architecture(const char* value);
+  inline void set_cpu_architecture(const char* value, size_t size);
+  inline ::std::string* mutable_cpu_architecture();
+  inline ::std::string* release_cpu_architecture();
+  inline void set_allocated_cpu_architecture(::std::string* cpu_architecture);
+
+  // optional string cpu_vendor = 2;
+  inline bool has_cpu_vendor() const;
+  inline void clear_cpu_vendor();
+  static const int kCpuVendorFieldNumber = 2;
+  inline const ::std::string& cpu_vendor() const;
+  inline void set_cpu_vendor(const ::std::string& value);
+  inline void set_cpu_vendor(const char* value);
+  inline void set_cpu_vendor(const char* value, size_t size);
+  inline ::std::string* mutable_cpu_vendor();
+  inline ::std::string* release_cpu_vendor();
+  inline void set_allocated_cpu_vendor(::std::string* cpu_vendor);
+
+  // optional uint32 cpuid = 3;
+  inline bool has_cpuid() const;
+  inline void clear_cpuid();
+  static const int kCpuidFieldNumber = 3;
+  inline ::google::protobuf::uint32 cpuid() const;
+  inline void set_cpuid(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Machine)
+ private:
+  inline void set_has_cpu_architecture();
+  inline void clear_has_cpu_architecture();
+  inline void set_has_cpu_vendor();
+  inline void clear_has_cpu_vendor();
+  inline void set_has_cpuid();
+  inline void clear_has_cpuid();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* cpu_architecture_;
+  ::std::string* cpu_vendor_;
+  ::google::protobuf::uint32 cpuid_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_EnvironmentData_Machine* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Process_Patch : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_EnvironmentData_Process_Patch();
+  virtual ~ClientIncidentReport_EnvironmentData_Process_Patch();
+
+  ClientIncidentReport_EnvironmentData_Process_Patch(const ClientIncidentReport_EnvironmentData_Process_Patch& from);
+
+  inline ClientIncidentReport_EnvironmentData_Process_Patch& operator=(const ClientIncidentReport_EnvironmentData_Process_Patch& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Process_Patch& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_EnvironmentData_Process_Patch* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_EnvironmentData_Process_Patch* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Process_Patch* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Process_Patch& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Process_Patch& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string function = 1;
+  inline bool has_function() const;
+  inline void clear_function();
+  static const int kFunctionFieldNumber = 1;
+  inline const ::std::string& function() const;
+  inline void set_function(const ::std::string& value);
+  inline void set_function(const char* value);
+  inline void set_function(const char* value, size_t size);
+  inline ::std::string* mutable_function();
+  inline ::std::string* release_function();
+  inline void set_allocated_function(::std::string* function);
+
+  // optional string target_dll = 2;
+  inline bool has_target_dll() const;
+  inline void clear_target_dll();
+  static const int kTargetDllFieldNumber = 2;
+  inline const ::std::string& target_dll() const;
+  inline void set_target_dll(const ::std::string& value);
+  inline void set_target_dll(const char* value);
+  inline void set_target_dll(const char* value, size_t size);
+  inline ::std::string* mutable_target_dll();
+  inline ::std::string* release_target_dll();
+  inline void set_allocated_target_dll(::std::string* target_dll);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch)
+ private:
+  inline void set_has_function();
+  inline void clear_has_function();
+  inline void set_has_target_dll();
+  inline void clear_has_target_dll();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* function_;
+  ::std::string* target_dll_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_EnvironmentData_Process_Patch* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Process_NetworkProvider : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_EnvironmentData_Process_NetworkProvider();
+  virtual ~ClientIncidentReport_EnvironmentData_Process_NetworkProvider();
+
+  ClientIncidentReport_EnvironmentData_Process_NetworkProvider(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from);
+
+  inline ClientIncidentReport_EnvironmentData_Process_NetworkProvider& operator=(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_EnvironmentData_Process_NetworkProvider* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_EnvironmentData_Process_NetworkProvider* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Process_NetworkProvider* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Process_NetworkProvider& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider)
+ private:
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_EnvironmentData_Process_NetworkProvider* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Process_Dll : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_EnvironmentData_Process_Dll();
+  virtual ~ClientIncidentReport_EnvironmentData_Process_Dll();
+
+  ClientIncidentReport_EnvironmentData_Process_Dll(const ClientIncidentReport_EnvironmentData_Process_Dll& from);
+
+  inline ClientIncidentReport_EnvironmentData_Process_Dll& operator=(const ClientIncidentReport_EnvironmentData_Process_Dll& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Process_Dll& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_EnvironmentData_Process_Dll* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_EnvironmentData_Process_Dll* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Process_Dll* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Process_Dll& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Process_Dll& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_EnvironmentData_Process_Dll_Feature Feature;
+  static const Feature UNKNOWN = ClientIncidentReport_EnvironmentData_Process_Dll_Feature_UNKNOWN;
+  static const Feature LSP = ClientIncidentReport_EnvironmentData_Process_Dll_Feature_LSP;
+  static inline bool Feature_IsValid(int value) {
+    return ClientIncidentReport_EnvironmentData_Process_Dll_Feature_IsValid(value);
+  }
+  static const Feature Feature_MIN =
+    ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_MIN;
+  static const Feature Feature_MAX =
+    ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_MAX;
+  static const int Feature_ARRAYSIZE =
+    ClientIncidentReport_EnvironmentData_Process_Dll_Feature_Feature_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional string path = 1;
+  inline bool has_path() const;
+  inline void clear_path();
+  static const int kPathFieldNumber = 1;
+  inline const ::std::string& path() const;
+  inline void set_path(const ::std::string& value);
+  inline void set_path(const char* value);
+  inline void set_path(const char* value, size_t size);
+  inline ::std::string* mutable_path();
+  inline ::std::string* release_path();
+  inline void set_allocated_path(::std::string* path);
+
+  // optional uint64 base_address = 2;
+  inline bool has_base_address() const;
+  inline void clear_base_address();
+  static const int kBaseAddressFieldNumber = 2;
+  inline ::google::protobuf::uint64 base_address() const;
+  inline void set_base_address(::google::protobuf::uint64 value);
+
+  // optional uint32 length = 3;
+  inline bool has_length() const;
+  inline void clear_length();
+  static const int kLengthFieldNumber = 3;
+  inline ::google::protobuf::uint32 length() const;
+  inline void set_length(::google::protobuf::uint32 value);
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.Feature feature = 4;
+  inline int feature_size() const;
+  inline void clear_feature();
+  static const int kFeatureFieldNumber = 4;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature feature(int index) const;
+  inline void set_feature(int index, ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature value);
+  inline void add_feature(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature value);
+  inline const ::google::protobuf::RepeatedField<int>& feature() const;
+  inline ::google::protobuf::RepeatedField<int>* mutable_feature();
+
+  // optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+  inline bool has_image_headers() const;
+  inline void clear_image_headers();
+  static const int kImageHeadersFieldNumber = 5;
+  inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& image_headers() const;
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* mutable_image_headers();
+  inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* release_image_headers();
+  inline void set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll)
+ private:
+  inline void set_has_path();
+  inline void clear_has_path();
+  inline void set_has_base_address();
+  inline void clear_has_base_address();
+  inline void set_has_length();
+  inline void clear_has_length();
+  inline void set_has_image_headers();
+  inline void clear_has_image_headers();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* path_;
+  ::google::protobuf::uint64 base_address_;
+  ::google::protobuf::RepeatedField<int> feature_;
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers_;
+  ::google::protobuf::uint32 length_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_EnvironmentData_Process_Dll* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification();
+  virtual ~ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification();
+
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from);
+
+  inline ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& operator=(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint32 file_offset = 1;
+  inline bool has_file_offset() const;
+  inline void clear_file_offset();
+  static const int kFileOffsetFieldNumber = 1;
+  inline ::google::protobuf::uint32 file_offset() const;
+  inline void set_file_offset(::google::protobuf::uint32 value);
+
+  // optional int32 byte_count = 2;
+  inline bool has_byte_count() const;
+  inline void clear_byte_count();
+  static const int kByteCountFieldNumber = 2;
+  inline ::google::protobuf::int32 byte_count() const;
+  inline void set_byte_count(::google::protobuf::int32 value);
+
+  // optional bytes modified_bytes = 3;
+  inline bool has_modified_bytes() const;
+  inline void clear_modified_bytes();
+  static const int kModifiedBytesFieldNumber = 3;
+  inline const ::std::string& modified_bytes() const;
+  inline void set_modified_bytes(const ::std::string& value);
+  inline void set_modified_bytes(const char* value);
+  inline void set_modified_bytes(const void* value, size_t size);
+  inline ::std::string* mutable_modified_bytes();
+  inline ::std::string* release_modified_bytes();
+  inline void set_allocated_modified_bytes(::std::string* modified_bytes);
+
+  // optional string export_name = 4;
+  inline bool has_export_name() const;
+  inline void clear_export_name();
+  static const int kExportNameFieldNumber = 4;
+  inline const ::std::string& export_name() const;
+  inline void set_export_name(const ::std::string& value);
+  inline void set_export_name(const char* value);
+  inline void set_export_name(const char* value, size_t size);
+  inline ::std::string* mutable_export_name();
+  inline ::std::string* release_export_name();
+  inline void set_allocated_export_name(::std::string* export_name);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification)
+ private:
+  inline void set_has_file_offset();
+  inline void clear_has_file_offset();
+  inline void set_has_byte_count();
+  inline void clear_has_byte_count();
+  inline void set_has_modified_bytes();
+  inline void clear_has_modified_bytes();
+  inline void set_has_export_name();
+  inline void clear_has_export_name();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 file_offset_;
+  ::google::protobuf::int32 byte_count_;
+  ::std::string* modified_bytes_;
+  ::std::string* export_name_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Process_ModuleState : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_EnvironmentData_Process_ModuleState();
+  virtual ~ClientIncidentReport_EnvironmentData_Process_ModuleState();
+
+  ClientIncidentReport_EnvironmentData_Process_ModuleState(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from);
+
+  inline ClientIncidentReport_EnvironmentData_Process_ModuleState& operator=(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Process_ModuleState& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_EnvironmentData_Process_ModuleState* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_EnvironmentData_Process_ModuleState* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Process_ModuleState* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Process_ModuleState& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification Modification;
+
+  typedef ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState ModifiedState;
+  static const ModifiedState UNKNOWN = ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_UNKNOWN;
+  static const ModifiedState MODULE_STATE_UNKNOWN = ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_MODULE_STATE_UNKNOWN;
+  static const ModifiedState MODULE_STATE_UNMODIFIED = ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_MODULE_STATE_UNMODIFIED;
+  static const 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 const ModifiedState ModifiedState_MIN =
+    ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_MIN;
+  static const ModifiedState ModifiedState_MAX =
+    ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_MAX;
+  static const int ModifiedState_ARRAYSIZE =
+    ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_ModifiedState_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional string name = 1;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 1;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.ModifiedState modified_state = 2;
+  inline bool has_modified_state() const;
+  inline void clear_modified_state();
+  static const int kModifiedStateFieldNumber = 2;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState modified_state() const;
+  inline void set_modified_state(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState value);
+
+  // repeated string OBSOLETE_modified_export = 3;
+  inline int obsolete_modified_export_size() const;
+  inline void clear_obsolete_modified_export();
+  static const int kOBSOLETEModifiedExportFieldNumber = 3;
+  inline const ::std::string& obsolete_modified_export(int index) const;
+  inline ::std::string* mutable_obsolete_modified_export(int index);
+  inline void set_obsolete_modified_export(int index, const ::std::string& value);
+  inline void set_obsolete_modified_export(int index, const char* value);
+  inline void set_obsolete_modified_export(int index, const char* value, size_t size);
+  inline ::std::string* add_obsolete_modified_export();
+  inline void add_obsolete_modified_export(const ::std::string& value);
+  inline void add_obsolete_modified_export(const char* value);
+  inline void add_obsolete_modified_export(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& obsolete_modified_export() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_obsolete_modified_export();
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification modification = 4;
+  inline int modification_size() const;
+  inline void clear_modification();
+  static const int kModificationFieldNumber = 4;
+  inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification& modification(int index) const;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* mutable_modification(int index);
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification* add_modification();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification >&
+      modification() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification >*
+      mutable_modification();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_modified_state();
+  inline void clear_has_modified_state();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* name_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> obsolete_modified_export_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification > modification_;
+  int modified_state_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_EnvironmentData_Process_ModuleState* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData_Process : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_EnvironmentData_Process();
+  virtual ~ClientIncidentReport_EnvironmentData_Process();
+
+  ClientIncidentReport_EnvironmentData_Process(const ClientIncidentReport_EnvironmentData_Process& from);
+
+  inline ClientIncidentReport_EnvironmentData_Process& operator=(const ClientIncidentReport_EnvironmentData_Process& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_EnvironmentData_Process& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_EnvironmentData_Process* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_EnvironmentData_Process* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData_Process* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_EnvironmentData_Process& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData_Process& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef 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 const Channel CHANNEL_UNKNOWN = ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_UNKNOWN;
+  static const Channel CHANNEL_CANARY = ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_CANARY;
+  static const Channel CHANNEL_DEV = ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_DEV;
+  static const Channel CHANNEL_BETA = ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_BETA;
+  static const Channel CHANNEL_STABLE = ClientIncidentReport_EnvironmentData_Process_Channel_CHANNEL_STABLE;
+  static inline bool Channel_IsValid(int value) {
+    return ClientIncidentReport_EnvironmentData_Process_Channel_IsValid(value);
+  }
+  static const Channel Channel_MIN =
+    ClientIncidentReport_EnvironmentData_Process_Channel_Channel_MIN;
+  static const Channel Channel_MAX =
+    ClientIncidentReport_EnvironmentData_Process_Channel_Channel_MAX;
+  static const int Channel_ARRAYSIZE =
+    ClientIncidentReport_EnvironmentData_Process_Channel_Channel_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional string version = 1;
+  inline bool has_version() const;
+  inline void clear_version();
+  static const int kVersionFieldNumber = 1;
+  inline const ::std::string& version() const;
+  inline void set_version(const ::std::string& value);
+  inline void set_version(const char* value);
+  inline void set_version(const char* value, size_t size);
+  inline ::std::string* mutable_version();
+  inline ::std::string* release_version();
+  inline void set_allocated_version(::std::string* version);
+
+  // repeated string OBSOLETE_dlls = 2;
+  inline int obsolete_dlls_size() const;
+  inline void clear_obsolete_dlls();
+  static const int kOBSOLETEDllsFieldNumber = 2;
+  inline const ::std::string& obsolete_dlls(int index) const;
+  inline ::std::string* mutable_obsolete_dlls(int index);
+  inline void set_obsolete_dlls(int index, const ::std::string& value);
+  inline void set_obsolete_dlls(int index, const char* value);
+  inline void set_obsolete_dlls(int index, const char* value, size_t size);
+  inline ::std::string* add_obsolete_dlls();
+  inline void add_obsolete_dlls(const ::std::string& value);
+  inline void add_obsolete_dlls(const char* value);
+  inline void add_obsolete_dlls(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& obsolete_dlls() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_obsolete_dlls();
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch patches = 3;
+  inline int patches_size() const;
+  inline void clear_patches();
+  static const int kPatchesFieldNumber = 3;
+  inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch& patches(int index) const;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch* mutable_patches(int index);
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch* add_patches();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch >&
+      patches() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch >*
+      mutable_patches();
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider network_providers = 4;
+  inline int network_providers_size() const;
+  inline void clear_network_providers();
+  static const int kNetworkProvidersFieldNumber = 4;
+  inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider& network_providers(int index) const;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider* mutable_network_providers(int index);
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider* add_network_providers();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider >&
+      network_providers() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider >*
+      mutable_network_providers();
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Channel chrome_update_channel = 5;
+  inline bool has_chrome_update_channel() const;
+  inline void clear_chrome_update_channel();
+  static const int kChromeUpdateChannelFieldNumber = 5;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel chrome_update_channel() const;
+  inline void set_chrome_update_channel(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel value);
+
+  // optional int64 uptime_msec = 6;
+  inline bool has_uptime_msec() const;
+  inline void clear_uptime_msec();
+  static const int kUptimeMsecFieldNumber = 6;
+  inline ::google::protobuf::int64 uptime_msec() const;
+  inline void set_uptime_msec(::google::protobuf::int64 value);
+
+  // optional bool metrics_consent = 7;
+  inline bool has_metrics_consent() const;
+  inline void clear_metrics_consent();
+  static const int kMetricsConsentFieldNumber = 7;
+  inline bool metrics_consent() const;
+  inline void set_metrics_consent(bool value);
+
+  // optional bool extended_consent = 8;
+  inline bool has_extended_consent() const;
+  inline void clear_extended_consent();
+  static const int kExtendedConsentFieldNumber = 8;
+  inline bool extended_consent() const;
+  inline void set_extended_consent(bool value);
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll dll = 9;
+  inline int dll_size() const;
+  inline void clear_dll();
+  static const int kDllFieldNumber = 9;
+  inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll& dll(int index) const;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll* mutable_dll(int index);
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll* add_dll();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll >&
+      dll() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll >*
+      mutable_dll();
+
+  // repeated string blacklisted_dll = 10;
+  inline int blacklisted_dll_size() const;
+  inline void clear_blacklisted_dll();
+  static const int kBlacklistedDllFieldNumber = 10;
+  inline const ::std::string& blacklisted_dll(int index) const;
+  inline ::std::string* mutable_blacklisted_dll(int index);
+  inline void set_blacklisted_dll(int index, const ::std::string& value);
+  inline void set_blacklisted_dll(int index, const char* value);
+  inline void set_blacklisted_dll(int index, const char* value, size_t size);
+  inline ::std::string* add_blacklisted_dll();
+  inline void add_blacklisted_dll(const ::std::string& value);
+  inline void add_blacklisted_dll(const char* value);
+  inline void add_blacklisted_dll(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& blacklisted_dll() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_blacklisted_dll();
+
+  // repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState module_state = 11;
+  inline int module_state_size() const;
+  inline void clear_module_state();
+  static const int kModuleStateFieldNumber = 11;
+  inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState& module_state(int index) const;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState* mutable_module_state(int index);
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState* add_module_state();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState >&
+      module_state() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState >*
+      mutable_module_state();
+
+  // optional bool field_trial_participant = 12;
+  inline bool has_field_trial_participant() const;
+  inline void clear_field_trial_participant();
+  static const int kFieldTrialParticipantFieldNumber = 12;
+  inline bool field_trial_participant() const;
+  inline void set_field_trial_participant(bool value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData.Process)
+ private:
+  inline void set_has_version();
+  inline void clear_has_version();
+  inline void set_has_chrome_update_channel();
+  inline void clear_has_chrome_update_channel();
+  inline void set_has_uptime_msec();
+  inline void clear_has_uptime_msec();
+  inline void set_has_metrics_consent();
+  inline void clear_has_metrics_consent();
+  inline void set_has_extended_consent();
+  inline void clear_has_extended_consent();
+  inline void set_has_field_trial_participant();
+  inline void clear_has_field_trial_participant();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* version_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> obsolete_dlls_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch > patches_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_NetworkProvider > network_providers_;
+  ::google::protobuf::int64 uptime_msec_;
+  int chrome_update_channel_;
+  bool metrics_consent_;
+  bool extended_consent_;
+  bool field_trial_participant_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll > dll_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> blacklisted_dll_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState > module_state_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_EnvironmentData_Process* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_EnvironmentData : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_EnvironmentData();
+  virtual ~ClientIncidentReport_EnvironmentData();
+
+  ClientIncidentReport_EnvironmentData(const ClientIncidentReport_EnvironmentData& from);
+
+  inline ClientIncidentReport_EnvironmentData& operator=(const ClientIncidentReport_EnvironmentData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_EnvironmentData& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_EnvironmentData* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_EnvironmentData* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_EnvironmentData* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_EnvironmentData& from);
+  void MergeFrom(const ClientIncidentReport_EnvironmentData& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_EnvironmentData_OS OS;
+  typedef ClientIncidentReport_EnvironmentData_Machine Machine;
+  typedef ClientIncidentReport_EnvironmentData_Process Process;
+
+  // accessors -------------------------------------------------------
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.OS os = 1;
+  inline bool has_os() const;
+  inline void clear_os();
+  static const int kOsFieldNumber = 1;
+  inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS& os() const;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* mutable_os();
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* release_os();
+  inline void set_allocated_os(::safe_browsing::ClientIncidentReport_EnvironmentData_OS* os);
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Machine machine = 2;
+  inline bool has_machine() const;
+  inline void clear_machine();
+  static const int kMachineFieldNumber = 2;
+  inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine& machine() const;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* mutable_machine();
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* release_machine();
+  inline void set_allocated_machine(::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* machine);
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process process = 3;
+  inline bool has_process() const;
+  inline void clear_process();
+  static const int kProcessFieldNumber = 3;
+  inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process& process() const;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* mutable_process();
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* release_process();
+  inline void set_allocated_process(::safe_browsing::ClientIncidentReport_EnvironmentData_Process* process);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.EnvironmentData)
+ private:
+  inline void set_has_os();
+  inline void clear_has_os();
+  inline void set_has_machine();
+  inline void clear_has_machine();
+  inline void set_has_process();
+  inline void clear_has_process();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* os_;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* machine_;
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* process_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_EnvironmentData* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_ExtensionData_ExtensionInfo : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_ExtensionData_ExtensionInfo();
+  virtual ~ClientIncidentReport_ExtensionData_ExtensionInfo();
+
+  ClientIncidentReport_ExtensionData_ExtensionInfo(const ClientIncidentReport_ExtensionData_ExtensionInfo& from);
+
+  inline ClientIncidentReport_ExtensionData_ExtensionInfo& operator=(const ClientIncidentReport_ExtensionData_ExtensionInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_ExtensionData_ExtensionInfo& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_ExtensionData_ExtensionInfo* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_ExtensionData_ExtensionInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_ExtensionData_ExtensionInfo* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_ExtensionData_ExtensionInfo& from);
+  void MergeFrom(const ClientIncidentReport_ExtensionData_ExtensionInfo& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState ExtensionState;
+  static const ExtensionState STATE_UNKNOWN = ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_UNKNOWN;
+  static const ExtensionState STATE_ENABLED = ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_ENABLED;
+  static const ExtensionState STATE_DISABLED = ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_DISABLED;
+  static const ExtensionState STATE_BLACKLISTED = ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_BLACKLISTED;
+  static const ExtensionState STATE_BLOCKED = ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_BLOCKED;
+  static const ExtensionState STATE_TERMINATED = ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_STATE_TERMINATED;
+  static inline bool ExtensionState_IsValid(int value) {
+    return ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_IsValid(value);
+  }
+  static const ExtensionState ExtensionState_MIN =
+    ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_MIN;
+  static const ExtensionState ExtensionState_MAX =
+    ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_MAX;
+  static const int ExtensionState_ARRAYSIZE =
+    ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_ExtensionState_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional string id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline const ::std::string& id() const;
+  inline void set_id(const ::std::string& value);
+  inline void set_id(const char* value);
+  inline void set_id(const char* value, size_t size);
+  inline ::std::string* mutable_id();
+  inline ::std::string* release_id();
+  inline void set_allocated_id(::std::string* id);
+
+  // optional string version = 2;
+  inline bool has_version() const;
+  inline void clear_version();
+  static const int kVersionFieldNumber = 2;
+  inline const ::std::string& version() const;
+  inline void set_version(const ::std::string& value);
+  inline void set_version(const char* value);
+  inline void set_version(const char* value, size_t size);
+  inline ::std::string* mutable_version();
+  inline ::std::string* release_version();
+  inline void set_allocated_version(::std::string* version);
+
+  // optional string name = 3;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 3;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional string description = 4;
+  inline bool has_description() const;
+  inline void clear_description();
+  static const int kDescriptionFieldNumber = 4;
+  inline const ::std::string& description() const;
+  inline void set_description(const ::std::string& value);
+  inline void set_description(const char* value);
+  inline void set_description(const char* value, size_t size);
+  inline ::std::string* mutable_description();
+  inline ::std::string* release_description();
+  inline void set_allocated_description(::std::string* description);
+
+  // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.ExtensionState state = 5 [default = STATE_UNKNOWN];
+  inline bool has_state() const;
+  inline void clear_state();
+  static const int kStateFieldNumber = 5;
+  inline ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState state() const;
+  inline void set_state(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState value);
+
+  // optional int32 type = 6;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 6;
+  inline ::google::protobuf::int32 type() const;
+  inline void set_type(::google::protobuf::int32 value);
+
+  // optional string update_url = 7;
+  inline bool has_update_url() const;
+  inline void clear_update_url();
+  static const int kUpdateUrlFieldNumber = 7;
+  inline const ::std::string& update_url() const;
+  inline void set_update_url(const ::std::string& value);
+  inline void set_update_url(const char* value);
+  inline void set_update_url(const char* value, size_t size);
+  inline ::std::string* mutable_update_url();
+  inline ::std::string* release_update_url();
+  inline void set_allocated_update_url(::std::string* update_url);
+
+  // optional bool has_signature_validation = 8;
+  inline bool has_has_signature_validation() const;
+  inline void clear_has_signature_validation();
+  static const int kHasSignatureValidationFieldNumber = 8;
+  inline bool has_signature_validation() const;
+  inline void set_has_signature_validation(bool value);
+
+  // optional bool signature_is_valid = 9;
+  inline bool has_signature_is_valid() const;
+  inline void clear_signature_is_valid();
+  static const int kSignatureIsValidFieldNumber = 9;
+  inline bool signature_is_valid() const;
+  inline void set_signature_is_valid(bool value);
+
+  // optional bool installed_by_custodian = 10;
+  inline bool has_installed_by_custodian() const;
+  inline void clear_installed_by_custodian();
+  static const int kInstalledByCustodianFieldNumber = 10;
+  inline bool installed_by_custodian() const;
+  inline void set_installed_by_custodian(bool value);
+
+  // optional bool installed_by_default = 11;
+  inline bool has_installed_by_default() const;
+  inline void clear_installed_by_default();
+  static const int kInstalledByDefaultFieldNumber = 11;
+  inline bool installed_by_default() const;
+  inline void set_installed_by_default(bool value);
+
+  // optional bool installed_by_oem = 12;
+  inline bool has_installed_by_oem() const;
+  inline void clear_installed_by_oem();
+  static const int kInstalledByOemFieldNumber = 12;
+  inline bool installed_by_oem() const;
+  inline void set_installed_by_oem(bool value);
+
+  // optional bool from_bookmark = 13;
+  inline bool has_from_bookmark() const;
+  inline void clear_from_bookmark();
+  static const int kFromBookmarkFieldNumber = 13;
+  inline bool from_bookmark() const;
+  inline void set_from_bookmark(bool value);
+
+  // optional bool from_webstore = 14;
+  inline bool has_from_webstore() const;
+  inline void clear_from_webstore();
+  static const int kFromWebstoreFieldNumber = 14;
+  inline bool from_webstore() const;
+  inline void set_from_webstore(bool value);
+
+  // optional bool converted_from_user_script = 15;
+  inline bool has_converted_from_user_script() const;
+  inline void clear_converted_from_user_script();
+  static const int kConvertedFromUserScriptFieldNumber = 15;
+  inline bool converted_from_user_script() const;
+  inline void set_converted_from_user_script(bool value);
+
+  // optional bool may_be_untrusted = 16;
+  inline bool has_may_be_untrusted() const;
+  inline void clear_may_be_untrusted();
+  static const int kMayBeUntrustedFieldNumber = 16;
+  inline bool may_be_untrusted() const;
+  inline void set_may_be_untrusted(bool value);
+
+  // optional int64 install_time_msec = 17;
+  inline bool has_install_time_msec() const;
+  inline void clear_install_time_msec();
+  static const int kInstallTimeMsecFieldNumber = 17;
+  inline ::google::protobuf::int64 install_time_msec() const;
+  inline void set_install_time_msec(::google::protobuf::int64 value);
+
+  // optional int32 manifest_location_type = 18;
+  inline bool has_manifest_location_type() const;
+  inline void clear_manifest_location_type();
+  static const int kManifestLocationTypeFieldNumber = 18;
+  inline ::google::protobuf::int32 manifest_location_type() const;
+  inline void set_manifest_location_type(::google::protobuf::int32 value);
+
+  // optional string manifest = 19;
+  inline bool has_manifest() const;
+  inline void clear_manifest();
+  static const int kManifestFieldNumber = 19;
+  inline const ::std::string& manifest() const;
+  inline void set_manifest(const ::std::string& value);
+  inline void set_manifest(const char* value);
+  inline void set_manifest(const char* value, size_t size);
+  inline ::std::string* mutable_manifest();
+  inline ::std::string* release_manifest();
+  inline void set_allocated_manifest(::std::string* manifest);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_version();
+  inline void clear_has_version();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_description();
+  inline void clear_has_description();
+  inline void set_has_state();
+  inline void clear_has_state();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_update_url();
+  inline void clear_has_update_url();
+  inline void set_has_has_signature_validation();
+  inline void clear_has_has_signature_validation();
+  inline void set_has_signature_is_valid();
+  inline void clear_has_signature_is_valid();
+  inline void set_has_installed_by_custodian();
+  inline void clear_has_installed_by_custodian();
+  inline void set_has_installed_by_default();
+  inline void clear_has_installed_by_default();
+  inline void set_has_installed_by_oem();
+  inline void clear_has_installed_by_oem();
+  inline void set_has_from_bookmark();
+  inline void clear_has_from_bookmark();
+  inline void set_has_from_webstore();
+  inline void clear_has_from_webstore();
+  inline void set_has_converted_from_user_script();
+  inline void clear_has_converted_from_user_script();
+  inline void set_has_may_be_untrusted();
+  inline void clear_has_may_be_untrusted();
+  inline void set_has_install_time_msec();
+  inline void clear_has_install_time_msec();
+  inline void set_has_manifest_location_type();
+  inline void clear_has_manifest_location_type();
+  inline void set_has_manifest();
+  inline void clear_has_manifest();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* id_;
+  ::std::string* version_;
+  ::std::string* name_;
+  ::std::string* description_;
+  int state_;
+  ::google::protobuf::int32 type_;
+  ::std::string* update_url_;
+  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_;
+  ::google::protobuf::int64 install_time_msec_;
+  bool may_be_untrusted_;
+  ::google::protobuf::int32 manifest_location_type_;
+  ::std::string* manifest_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_ExtensionData_ExtensionInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_ExtensionData : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_ExtensionData();
+  virtual ~ClientIncidentReport_ExtensionData();
+
+  ClientIncidentReport_ExtensionData(const ClientIncidentReport_ExtensionData& from);
+
+  inline ClientIncidentReport_ExtensionData& operator=(const ClientIncidentReport_ExtensionData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_ExtensionData& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_ExtensionData* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_ExtensionData* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_ExtensionData* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_ExtensionData& from);
+  void MergeFrom(const ClientIncidentReport_ExtensionData& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_ExtensionData_ExtensionInfo ExtensionInfo;
+
+  // accessors -------------------------------------------------------
+
+  // optional .safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo last_installed_extension = 1;
+  inline bool has_last_installed_extension() const;
+  inline void clear_last_installed_extension();
+  static const int kLastInstalledExtensionFieldNumber = 1;
+  inline const ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo& last_installed_extension() const;
+  inline ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* mutable_last_installed_extension();
+  inline ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* release_last_installed_extension();
+  inline void set_allocated_last_installed_extension(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* last_installed_extension);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.ExtensionData)
+ private:
+  inline void set_has_last_installed_extension();
+  inline void clear_has_last_installed_extension();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* last_installed_extension_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_ExtensionData* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport_NonBinaryDownloadDetails : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport_NonBinaryDownloadDetails();
+  virtual ~ClientIncidentReport_NonBinaryDownloadDetails();
+
+  ClientIncidentReport_NonBinaryDownloadDetails(const ClientIncidentReport_NonBinaryDownloadDetails& from);
+
+  inline ClientIncidentReport_NonBinaryDownloadDetails& operator=(const ClientIncidentReport_NonBinaryDownloadDetails& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport_NonBinaryDownloadDetails& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport_NonBinaryDownloadDetails* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport_NonBinaryDownloadDetails* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport_NonBinaryDownloadDetails* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport_NonBinaryDownloadDetails& from);
+  void MergeFrom(const ClientIncidentReport_NonBinaryDownloadDetails& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string file_type = 1;
+  inline bool has_file_type() const;
+  inline void clear_file_type();
+  static const int kFileTypeFieldNumber = 1;
+  inline const ::std::string& file_type() const;
+  inline void set_file_type(const ::std::string& value);
+  inline void set_file_type(const char* value);
+  inline void set_file_type(const char* value, size_t size);
+  inline ::std::string* mutable_file_type();
+  inline ::std::string* release_file_type();
+  inline void set_allocated_file_type(::std::string* file_type);
+
+  // optional bytes url_spec_sha256 = 2;
+  inline bool has_url_spec_sha256() const;
+  inline void clear_url_spec_sha256();
+  static const int kUrlSpecSha256FieldNumber = 2;
+  inline const ::std::string& url_spec_sha256() const;
+  inline void set_url_spec_sha256(const ::std::string& value);
+  inline void set_url_spec_sha256(const char* value);
+  inline void set_url_spec_sha256(const void* value, size_t size);
+  inline ::std::string* mutable_url_spec_sha256();
+  inline ::std::string* release_url_spec_sha256();
+  inline void set_allocated_url_spec_sha256(::std::string* url_spec_sha256);
+
+  // optional string host = 3;
+  inline bool has_host() const;
+  inline void clear_host();
+  static const int kHostFieldNumber = 3;
+  inline const ::std::string& host() const;
+  inline void set_host(const ::std::string& value);
+  inline void set_host(const char* value);
+  inline void set_host(const char* value, size_t size);
+  inline ::std::string* mutable_host();
+  inline ::std::string* release_host();
+  inline void set_allocated_host(::std::string* host);
+
+  // optional int64 length = 4;
+  inline bool has_length() const;
+  inline void clear_length();
+  static const int kLengthFieldNumber = 4;
+  inline ::google::protobuf::int64 length() const;
+  inline void set_length(::google::protobuf::int64 value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails)
+ private:
+  inline void set_has_file_type();
+  inline void clear_has_file_type();
+  inline void set_has_url_spec_sha256();
+  inline void clear_has_url_spec_sha256();
+  inline void set_has_host();
+  inline void clear_has_host();
+  inline void set_has_length();
+  inline void clear_has_length();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* file_type_;
+  ::std::string* url_spec_sha256_;
+  ::std::string* host_;
+  ::google::protobuf::int64 length_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport_NonBinaryDownloadDetails* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentReport : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentReport();
+  virtual ~ClientIncidentReport();
+
+  ClientIncidentReport(const ClientIncidentReport& from);
+
+  inline ClientIncidentReport& operator=(const ClientIncidentReport& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentReport& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentReport* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentReport* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentReport* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentReport& from);
+  void MergeFrom(const ClientIncidentReport& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentReport_IncidentData IncidentData;
+  typedef ClientIncidentReport_DownloadDetails DownloadDetails;
+  typedef ClientIncidentReport_EnvironmentData EnvironmentData;
+  typedef ClientIncidentReport_ExtensionData ExtensionData;
+  typedef ClientIncidentReport_NonBinaryDownloadDetails NonBinaryDownloadDetails;
+
+  // accessors -------------------------------------------------------
+
+  // repeated .safe_browsing.ClientIncidentReport.IncidentData incident = 1;
+  inline int incident_size() const;
+  inline void clear_incident();
+  static const int kIncidentFieldNumber = 1;
+  inline const ::safe_browsing::ClientIncidentReport_IncidentData& incident(int index) const;
+  inline ::safe_browsing::ClientIncidentReport_IncidentData* mutable_incident(int index);
+  inline ::safe_browsing::ClientIncidentReport_IncidentData* add_incident();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData >&
+      incident() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData >*
+      mutable_incident();
+
+  // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+  inline bool has_download() const;
+  inline void clear_download();
+  static const int kDownloadFieldNumber = 2;
+  inline const ::safe_browsing::ClientIncidentReport_DownloadDetails& download() const;
+  inline ::safe_browsing::ClientIncidentReport_DownloadDetails* mutable_download();
+  inline ::safe_browsing::ClientIncidentReport_DownloadDetails* release_download();
+  inline void set_allocated_download(::safe_browsing::ClientIncidentReport_DownloadDetails* download);
+
+  // optional .safe_browsing.ClientIncidentReport.EnvironmentData environment = 3;
+  inline bool has_environment() const;
+  inline void clear_environment();
+  static const int kEnvironmentFieldNumber = 3;
+  inline const ::safe_browsing::ClientIncidentReport_EnvironmentData& environment() const;
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData* mutable_environment();
+  inline ::safe_browsing::ClientIncidentReport_EnvironmentData* release_environment();
+  inline void set_allocated_environment(::safe_browsing::ClientIncidentReport_EnvironmentData* environment);
+
+  // optional .safe_browsing.ChromeUserPopulation population = 7;
+  inline bool has_population() const;
+  inline void clear_population();
+  static const int kPopulationFieldNumber = 7;
+  inline const ::safe_browsing::ChromeUserPopulation& population() const;
+  inline ::safe_browsing::ChromeUserPopulation* mutable_population();
+  inline ::safe_browsing::ChromeUserPopulation* release_population();
+  inline void set_allocated_population(::safe_browsing::ChromeUserPopulation* population);
+
+  // optional .safe_browsing.ClientIncidentReport.ExtensionData extension_data = 8;
+  inline bool has_extension_data() const;
+  inline void clear_extension_data();
+  static const int kExtensionDataFieldNumber = 8;
+  inline const ::safe_browsing::ClientIncidentReport_ExtensionData& extension_data() const;
+  inline ::safe_browsing::ClientIncidentReport_ExtensionData* mutable_extension_data();
+  inline ::safe_browsing::ClientIncidentReport_ExtensionData* release_extension_data();
+  inline void set_allocated_extension_data(::safe_browsing::ClientIncidentReport_ExtensionData* extension_data);
+
+  // optional .safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails non_binary_download = 9;
+  inline bool has_non_binary_download() const;
+  inline void clear_non_binary_download();
+  static const int kNonBinaryDownloadFieldNumber = 9;
+  inline const ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails& non_binary_download() const;
+  inline ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* mutable_non_binary_download();
+  inline ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* release_non_binary_download();
+  inline void set_allocated_non_binary_download(::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* non_binary_download);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentReport)
+ private:
+  inline void set_has_download();
+  inline void clear_has_download();
+  inline void set_has_environment();
+  inline void clear_has_environment();
+  inline void set_has_population();
+  inline void clear_has_population();
+  inline void set_has_extension_data();
+  inline void clear_has_extension_data();
+  inline void set_has_non_binary_download();
+  inline void clear_has_non_binary_download();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::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_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentReport* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentResponse_EnvironmentRequest : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentResponse_EnvironmentRequest();
+  virtual ~ClientIncidentResponse_EnvironmentRequest();
+
+  ClientIncidentResponse_EnvironmentRequest(const ClientIncidentResponse_EnvironmentRequest& from);
+
+  inline ClientIncidentResponse_EnvironmentRequest& operator=(const ClientIncidentResponse_EnvironmentRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentResponse_EnvironmentRequest& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentResponse_EnvironmentRequest* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentResponse_EnvironmentRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentResponse_EnvironmentRequest* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentResponse_EnvironmentRequest& from);
+  void MergeFrom(const ClientIncidentResponse_EnvironmentRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional int32 dll_index = 1;
+  inline bool has_dll_index() const;
+  inline void clear_dll_index();
+  static const int kDllIndexFieldNumber = 1;
+  inline ::google::protobuf::int32 dll_index() const;
+  inline void set_dll_index(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentResponse.EnvironmentRequest)
+ private:
+  inline void set_has_dll_index();
+  inline void clear_has_dll_index();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::int32 dll_index_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentResponse_EnvironmentRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientIncidentResponse : public ::google::protobuf::MessageLite {
+ public:
+  ClientIncidentResponse();
+  virtual ~ClientIncidentResponse();
+
+  ClientIncidentResponse(const ClientIncidentResponse& from);
+
+  inline ClientIncidentResponse& operator=(const ClientIncidentResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientIncidentResponse& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientIncidentResponse* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientIncidentResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientIncidentResponse* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientIncidentResponse& from);
+  void MergeFrom(const ClientIncidentResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIncidentResponse_EnvironmentRequest EnvironmentRequest;
+
+  // accessors -------------------------------------------------------
+
+  // optional bytes token = 1;
+  inline bool has_token() const;
+  inline void clear_token();
+  static const int kTokenFieldNumber = 1;
+  inline const ::std::string& token() const;
+  inline void set_token(const ::std::string& value);
+  inline void set_token(const char* value);
+  inline void set_token(const void* value, size_t size);
+  inline ::std::string* mutable_token();
+  inline ::std::string* release_token();
+  inline void set_allocated_token(::std::string* token);
+
+  // optional bool download_requested = 2;
+  inline bool has_download_requested() const;
+  inline void clear_download_requested();
+  static const int kDownloadRequestedFieldNumber = 2;
+  inline bool download_requested() const;
+  inline void set_download_requested(bool value);
+
+  // repeated .safe_browsing.ClientIncidentResponse.EnvironmentRequest environment_requests = 3;
+  inline int environment_requests_size() const;
+  inline void clear_environment_requests();
+  static const int kEnvironmentRequestsFieldNumber = 3;
+  inline const ::safe_browsing::ClientIncidentResponse_EnvironmentRequest& environment_requests(int index) const;
+  inline ::safe_browsing::ClientIncidentResponse_EnvironmentRequest* mutable_environment_requests(int index);
+  inline ::safe_browsing::ClientIncidentResponse_EnvironmentRequest* add_environment_requests();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest >&
+      environment_requests() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest >*
+      mutable_environment_requests();
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientIncidentResponse)
+ private:
+  inline void set_has_token();
+  inline void clear_has_token();
+  inline void set_has_download_requested();
+  inline void clear_has_download_requested();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* token_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest > environment_requests_;
+  bool download_requested_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientIncidentResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class DownloadMetadata : public ::google::protobuf::MessageLite {
+ public:
+  DownloadMetadata();
+  virtual ~DownloadMetadata();
+
+  DownloadMetadata(const DownloadMetadata& from);
+
+  inline DownloadMetadata& operator=(const DownloadMetadata& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const DownloadMetadata& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const DownloadMetadata* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(DownloadMetadata* other);
+
+  // implements Message ----------------------------------------------
+
+  DownloadMetadata* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const DownloadMetadata& from);
+  void MergeFrom(const DownloadMetadata& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint32 download_id = 1;
+  inline bool has_download_id() const;
+  inline void clear_download_id();
+  static const int kDownloadIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 download_id() const;
+  inline void set_download_id(::google::protobuf::uint32 value);
+
+  // optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+  inline bool has_download() const;
+  inline void clear_download();
+  static const int kDownloadFieldNumber = 2;
+  inline const ::safe_browsing::ClientIncidentReport_DownloadDetails& download() const;
+  inline ::safe_browsing::ClientIncidentReport_DownloadDetails* mutable_download();
+  inline ::safe_browsing::ClientIncidentReport_DownloadDetails* release_download();
+  inline void set_allocated_download(::safe_browsing::ClientIncidentReport_DownloadDetails* download);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.DownloadMetadata)
+ private:
+  inline void set_has_download_id();
+  inline void clear_has_download_id();
+  inline void set_has_download();
+  inline void clear_has_download();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* download_;
+  ::google::protobuf::uint32 download_id_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static DownloadMetadata* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest_HTTPHeader : public ::google::protobuf::MessageLite {
+ public:
+  ClientSafeBrowsingReportRequest_HTTPHeader();
+  virtual ~ClientSafeBrowsingReportRequest_HTTPHeader();
+
+  ClientSafeBrowsingReportRequest_HTTPHeader(const ClientSafeBrowsingReportRequest_HTTPHeader& from);
+
+  inline ClientSafeBrowsingReportRequest_HTTPHeader& operator=(const ClientSafeBrowsingReportRequest_HTTPHeader& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientSafeBrowsingReportRequest_HTTPHeader& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientSafeBrowsingReportRequest_HTTPHeader* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientSafeBrowsingReportRequest_HTTPHeader* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest_HTTPHeader* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientSafeBrowsingReportRequest_HTTPHeader& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest_HTTPHeader& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required bytes name = 1;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 1;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const void* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional bytes value = 2;
+  inline bool has_value() const;
+  inline void clear_value();
+  static const int kValueFieldNumber = 2;
+  inline const ::std::string& value() const;
+  inline void set_value(const ::std::string& value);
+  inline void set_value(const char* value);
+  inline void set_value(const void* value, size_t size);
+  inline ::std::string* mutable_value();
+  inline ::std::string* release_value();
+  inline void set_allocated_value(::std::string* value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_value();
+  inline void clear_has_value();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* name_;
+  ::std::string* value_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientSafeBrowsingReportRequest_HTTPHeader* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine : public ::google::protobuf::MessageLite {
+ public:
+  ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine();
+  virtual ~ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine();
+
+  ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from);
+
+  inline ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& operator=(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bytes verb = 1;
+  inline bool has_verb() const;
+  inline void clear_verb();
+  static const int kVerbFieldNumber = 1;
+  inline const ::std::string& verb() const;
+  inline void set_verb(const ::std::string& value);
+  inline void set_verb(const char* value);
+  inline void set_verb(const void* value, size_t size);
+  inline ::std::string* mutable_verb();
+  inline ::std::string* release_verb();
+  inline void set_allocated_verb(::std::string* verb);
+
+  // optional bytes uri = 2;
+  inline bool has_uri() const;
+  inline void clear_uri();
+  static const int kUriFieldNumber = 2;
+  inline const ::std::string& uri() const;
+  inline void set_uri(const ::std::string& value);
+  inline void set_uri(const char* value);
+  inline void set_uri(const void* value, size_t size);
+  inline ::std::string* mutable_uri();
+  inline ::std::string* release_uri();
+  inline void set_allocated_uri(::std::string* uri);
+
+  // optional bytes version = 3;
+  inline bool has_version() const;
+  inline void clear_version();
+  static const int kVersionFieldNumber = 3;
+  inline const ::std::string& version() const;
+  inline void set_version(const ::std::string& value);
+  inline void set_version(const char* value);
+  inline void set_version(const void* value, size_t size);
+  inline ::std::string* mutable_version();
+  inline ::std::string* release_version();
+  inline void set_allocated_version(::std::string* version);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine)
+ private:
+  inline void set_has_verb();
+  inline void clear_has_verb();
+  inline void set_has_uri();
+  inline void clear_has_uri();
+  inline void set_has_version();
+  inline void clear_has_version();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* verb_;
+  ::std::string* uri_;
+  ::std::string* version_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest_HTTPRequest : public ::google::protobuf::MessageLite {
+ public:
+  ClientSafeBrowsingReportRequest_HTTPRequest();
+  virtual ~ClientSafeBrowsingReportRequest_HTTPRequest();
+
+  ClientSafeBrowsingReportRequest_HTTPRequest(const ClientSafeBrowsingReportRequest_HTTPRequest& from);
+
+  inline ClientSafeBrowsingReportRequest_HTTPRequest& operator=(const ClientSafeBrowsingReportRequest_HTTPRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientSafeBrowsingReportRequest_HTTPRequest& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientSafeBrowsingReportRequest_HTTPRequest* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientSafeBrowsingReportRequest_HTTPRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest_HTTPRequest* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientSafeBrowsingReportRequest_HTTPRequest& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest_HTTPRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine FirstLine;
+
+  // accessors -------------------------------------------------------
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine firstline = 1;
+  inline bool has_firstline() const;
+  inline void clear_firstline();
+  static const int kFirstlineFieldNumber = 1;
+  inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& firstline() const;
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* mutable_firstline();
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* release_firstline();
+  inline void set_allocated_firstline(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* firstline);
+
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+  inline int headers_size() const;
+  inline void clear_headers();
+  static const int kHeadersFieldNumber = 2;
+  inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& headers(int index) const;
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* mutable_headers(int index);
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* add_headers();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >&
+      headers() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >*
+      mutable_headers();
+
+  // optional bytes body = 3;
+  inline bool has_body() const;
+  inline void clear_body();
+  static const int kBodyFieldNumber = 3;
+  inline const ::std::string& body() const;
+  inline void set_body(const ::std::string& value);
+  inline void set_body(const char* value);
+  inline void set_body(const void* value, size_t size);
+  inline ::std::string* mutable_body();
+  inline ::std::string* release_body();
+  inline void set_allocated_body(::std::string* body);
+
+  // optional bytes bodydigest = 4;
+  inline bool has_bodydigest() const;
+  inline void clear_bodydigest();
+  static const int kBodydigestFieldNumber = 4;
+  inline const ::std::string& bodydigest() const;
+  inline void set_bodydigest(const ::std::string& value);
+  inline void set_bodydigest(const char* value);
+  inline void set_bodydigest(const void* value, size_t size);
+  inline ::std::string* mutable_bodydigest();
+  inline ::std::string* release_bodydigest();
+  inline void set_allocated_bodydigest(::std::string* bodydigest);
+
+  // optional int32 bodylength = 5;
+  inline bool has_bodylength() const;
+  inline void clear_bodylength();
+  static const int kBodylengthFieldNumber = 5;
+  inline ::google::protobuf::int32 bodylength() const;
+  inline void set_bodylength(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest)
+ private:
+  inline void set_has_firstline();
+  inline void clear_has_firstline();
+  inline void set_has_body();
+  inline void clear_has_body();
+  inline void set_has_bodydigest();
+  inline void clear_has_bodydigest();
+  inline void set_has_bodylength();
+  inline void clear_has_bodylength();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* firstline_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader > headers_;
+  ::std::string* body_;
+  ::std::string* bodydigest_;
+  ::google::protobuf::int32 bodylength_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientSafeBrowsingReportRequest_HTTPRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine : public ::google::protobuf::MessageLite {
+ public:
+  ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine();
+  virtual ~ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine();
+
+  ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from);
+
+  inline ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& operator=(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional int32 code = 1;
+  inline bool has_code() const;
+  inline void clear_code();
+  static const int kCodeFieldNumber = 1;
+  inline ::google::protobuf::int32 code() const;
+  inline void set_code(::google::protobuf::int32 value);
+
+  // optional bytes reason = 2;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 2;
+  inline const ::std::string& reason() const;
+  inline void set_reason(const ::std::string& value);
+  inline void set_reason(const char* value);
+  inline void set_reason(const void* value, size_t size);
+  inline ::std::string* mutable_reason();
+  inline ::std::string* release_reason();
+  inline void set_allocated_reason(::std::string* reason);
+
+  // optional bytes version = 3;
+  inline bool has_version() const;
+  inline void clear_version();
+  static const int kVersionFieldNumber = 3;
+  inline const ::std::string& version() const;
+  inline void set_version(const ::std::string& value);
+  inline void set_version(const char* value);
+  inline void set_version(const void* value, size_t size);
+  inline ::std::string* mutable_version();
+  inline ::std::string* release_version();
+  inline void set_allocated_version(::std::string* version);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine)
+ private:
+  inline void set_has_code();
+  inline void clear_has_code();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+  inline void set_has_version();
+  inline void clear_has_version();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* reason_;
+  ::std::string* version_;
+  ::google::protobuf::int32 code_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest_HTTPResponse : public ::google::protobuf::MessageLite {
+ public:
+  ClientSafeBrowsingReportRequest_HTTPResponse();
+  virtual ~ClientSafeBrowsingReportRequest_HTTPResponse();
+
+  ClientSafeBrowsingReportRequest_HTTPResponse(const ClientSafeBrowsingReportRequest_HTTPResponse& from);
+
+  inline ClientSafeBrowsingReportRequest_HTTPResponse& operator=(const ClientSafeBrowsingReportRequest_HTTPResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientSafeBrowsingReportRequest_HTTPResponse& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientSafeBrowsingReportRequest_HTTPResponse* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientSafeBrowsingReportRequest_HTTPResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest_HTTPResponse* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientSafeBrowsingReportRequest_HTTPResponse& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest_HTTPResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine FirstLine;
+
+  // accessors -------------------------------------------------------
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine firstline = 1;
+  inline bool has_firstline() const;
+  inline void clear_firstline();
+  static const int kFirstlineFieldNumber = 1;
+  inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& firstline() const;
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* mutable_firstline();
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* release_firstline();
+  inline void set_allocated_firstline(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* firstline);
+
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+  inline int headers_size() const;
+  inline void clear_headers();
+  static const int kHeadersFieldNumber = 2;
+  inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& headers(int index) const;
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* mutable_headers(int index);
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* add_headers();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >&
+      headers() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >*
+      mutable_headers();
+
+  // optional bytes body = 3;
+  inline bool has_body() const;
+  inline void clear_body();
+  static const int kBodyFieldNumber = 3;
+  inline const ::std::string& body() const;
+  inline void set_body(const ::std::string& value);
+  inline void set_body(const char* value);
+  inline void set_body(const void* value, size_t size);
+  inline ::std::string* mutable_body();
+  inline ::std::string* release_body();
+  inline void set_allocated_body(::std::string* body);
+
+  // optional bytes bodydigest = 4;
+  inline bool has_bodydigest() const;
+  inline void clear_bodydigest();
+  static const int kBodydigestFieldNumber = 4;
+  inline const ::std::string& bodydigest() const;
+  inline void set_bodydigest(const ::std::string& value);
+  inline void set_bodydigest(const char* value);
+  inline void set_bodydigest(const void* value, size_t size);
+  inline ::std::string* mutable_bodydigest();
+  inline ::std::string* release_bodydigest();
+  inline void set_allocated_bodydigest(::std::string* bodydigest);
+
+  // optional int32 bodylength = 5;
+  inline bool has_bodylength() const;
+  inline void clear_bodylength();
+  static const int kBodylengthFieldNumber = 5;
+  inline ::google::protobuf::int32 bodylength() const;
+  inline void set_bodylength(::google::protobuf::int32 value);
+
+  // optional bytes remote_ip = 6;
+  inline bool has_remote_ip() const;
+  inline void clear_remote_ip();
+  static const int kRemoteIpFieldNumber = 6;
+  inline const ::std::string& remote_ip() const;
+  inline void set_remote_ip(const ::std::string& value);
+  inline void set_remote_ip(const char* value);
+  inline void set_remote_ip(const void* value, size_t size);
+  inline ::std::string* mutable_remote_ip();
+  inline ::std::string* release_remote_ip();
+  inline void set_allocated_remote_ip(::std::string* remote_ip);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse)
+ private:
+  inline void set_has_firstline();
+  inline void clear_has_firstline();
+  inline void set_has_body();
+  inline void clear_has_body();
+  inline void set_has_bodydigest();
+  inline void clear_has_bodydigest();
+  inline void set_has_bodylength();
+  inline void clear_has_bodylength();
+  inline void set_has_remote_ip();
+  inline void clear_has_remote_ip();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* firstline_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader > headers_;
+  ::std::string* body_;
+  ::std::string* bodydigest_;
+  ::std::string* remote_ip_;
+  ::google::protobuf::int32 bodylength_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientSafeBrowsingReportRequest_HTTPResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest_Resource : public ::google::protobuf::MessageLite {
+ public:
+  ClientSafeBrowsingReportRequest_Resource();
+  virtual ~ClientSafeBrowsingReportRequest_Resource();
+
+  ClientSafeBrowsingReportRequest_Resource(const ClientSafeBrowsingReportRequest_Resource& from);
+
+  inline ClientSafeBrowsingReportRequest_Resource& operator=(const ClientSafeBrowsingReportRequest_Resource& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientSafeBrowsingReportRequest_Resource& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientSafeBrowsingReportRequest_Resource* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientSafeBrowsingReportRequest_Resource* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest_Resource* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientSafeBrowsingReportRequest_Resource& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest_Resource& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required int32 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::int32 id() const;
+  inline void set_id(::google::protobuf::int32 value);
+
+  // optional string url = 2;
+  inline bool has_url() const;
+  inline void clear_url();
+  static const int kUrlFieldNumber = 2;
+  inline const ::std::string& url() const;
+  inline void set_url(const ::std::string& value);
+  inline void set_url(const char* value);
+  inline void set_url(const char* value, size_t size);
+  inline ::std::string* mutable_url();
+  inline ::std::string* release_url();
+  inline void set_allocated_url(::std::string* url);
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest request = 3;
+  inline bool has_request() const;
+  inline void clear_request();
+  static const int kRequestFieldNumber = 3;
+  inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest& request() const;
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* mutable_request();
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* release_request();
+  inline void set_allocated_request(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* request);
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse response = 4;
+  inline bool has_response() const;
+  inline void clear_response();
+  static const int kResponseFieldNumber = 4;
+  inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse& response() const;
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* mutable_response();
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* release_response();
+  inline void set_allocated_response(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* response);
+
+  // optional int32 parent_id = 5;
+  inline bool has_parent_id() const;
+  inline void clear_parent_id();
+  static const int kParentIdFieldNumber = 5;
+  inline ::google::protobuf::int32 parent_id() const;
+  inline void set_parent_id(::google::protobuf::int32 value);
+
+  // repeated int32 child_ids = 6;
+  inline int child_ids_size() const;
+  inline void clear_child_ids();
+  static const int kChildIdsFieldNumber = 6;
+  inline ::google::protobuf::int32 child_ids(int index) const;
+  inline void set_child_ids(int index, ::google::protobuf::int32 value);
+  inline void add_child_ids(::google::protobuf::int32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+      child_ids() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+      mutable_child_ids();
+
+  // optional string tag_name = 7;
+  inline bool has_tag_name() const;
+  inline void clear_tag_name();
+  static const int kTagNameFieldNumber = 7;
+  inline const ::std::string& tag_name() const;
+  inline void set_tag_name(const ::std::string& value);
+  inline void set_tag_name(const char* value);
+  inline void set_tag_name(const char* value, size_t size);
+  inline ::std::string* mutable_tag_name();
+  inline ::std::string* release_tag_name();
+  inline void set_allocated_tag_name(::std::string* tag_name);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest.Resource)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_url();
+  inline void clear_has_url();
+  inline void set_has_request();
+  inline void clear_has_request();
+  inline void set_has_response();
+  inline void clear_has_response();
+  inline void set_has_parent_id();
+  inline void clear_has_parent_id();
+  inline void set_has_tag_name();
+  inline void clear_has_tag_name();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* url_;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* request_;
+  ::google::protobuf::int32 id_;
+  ::google::protobuf::int32 parent_id_;
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* response_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > child_ids_;
+  ::std::string* tag_name_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientSafeBrowsingReportRequest_Resource* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClientSafeBrowsingReportRequest : public ::google::protobuf::MessageLite {
+ public:
+  ClientSafeBrowsingReportRequest();
+  virtual ~ClientSafeBrowsingReportRequest();
+
+  ClientSafeBrowsingReportRequest(const ClientSafeBrowsingReportRequest& from);
+
+  inline ClientSafeBrowsingReportRequest& operator=(const ClientSafeBrowsingReportRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ClientSafeBrowsingReportRequest& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const ClientSafeBrowsingReportRequest* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(ClientSafeBrowsingReportRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientSafeBrowsingReportRequest* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClientSafeBrowsingReportRequest& from);
+  void MergeFrom(const ClientSafeBrowsingReportRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientSafeBrowsingReportRequest_HTTPHeader HTTPHeader;
+  typedef ClientSafeBrowsingReportRequest_HTTPRequest HTTPRequest;
+  typedef ClientSafeBrowsingReportRequest_HTTPResponse HTTPResponse;
+  typedef ClientSafeBrowsingReportRequest_Resource Resource;
+
+  typedef ClientSafeBrowsingReportRequest_ReportType ReportType;
+  static const ReportType UNKNOWN = ClientSafeBrowsingReportRequest_ReportType_UNKNOWN;
+  static const ReportType URL_PHISHING = ClientSafeBrowsingReportRequest_ReportType_URL_PHISHING;
+  static const ReportType URL_MALWARE = ClientSafeBrowsingReportRequest_ReportType_URL_MALWARE;
+  static const ReportType URL_UNWANTED = ClientSafeBrowsingReportRequest_ReportType_URL_UNWANTED;
+  static const ReportType CLIENT_SIDE_PHISHING_URL = ClientSafeBrowsingReportRequest_ReportType_CLIENT_SIDE_PHISHING_URL;
+  static const ReportType CLIENT_SIDE_MALWARE_URL = ClientSafeBrowsingReportRequest_ReportType_CLIENT_SIDE_MALWARE_URL;
+  static const ReportType DANGEROUS_DOWNLOAD_RECOVERY = ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_RECOVERY;
+  static const ReportType DANGEROUS_DOWNLOAD_WARNING = ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_WARNING;
+  static const ReportType DANGEROUS_DOWNLOAD_BY_API = ClientSafeBrowsingReportRequest_ReportType_DANGEROUS_DOWNLOAD_BY_API;
+  static inline bool ReportType_IsValid(int value) {
+    return ClientSafeBrowsingReportRequest_ReportType_IsValid(value);
+  }
+  static const ReportType ReportType_MIN =
+    ClientSafeBrowsingReportRequest_ReportType_ReportType_MIN;
+  static const ReportType ReportType_MAX =
+    ClientSafeBrowsingReportRequest_ReportType_ReportType_MAX;
+  static const int ReportType_ARRAYSIZE =
+    ClientSafeBrowsingReportRequest_ReportType_ReportType_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional .safe_browsing.ClientSafeBrowsingReportRequest.ReportType type = 10;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 10;
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_ReportType type() const;
+  inline void set_type(::safe_browsing::ClientSafeBrowsingReportRequest_ReportType value);
+
+  // optional .safe_browsing.ClientDownloadResponse.Verdict download_verdict = 11;
+  inline bool has_download_verdict() const;
+  inline void clear_download_verdict();
+  static const int kDownloadVerdictFieldNumber = 11;
+  inline ::safe_browsing::ClientDownloadResponse_Verdict download_verdict() const;
+  inline void set_download_verdict(::safe_browsing::ClientDownloadResponse_Verdict value);
+
+  // optional string url = 1;
+  inline bool has_url() const;
+  inline void clear_url();
+  static const int kUrlFieldNumber = 1;
+  inline const ::std::string& url() const;
+  inline void set_url(const ::std::string& value);
+  inline void set_url(const char* value);
+  inline void set_url(const char* value, size_t size);
+  inline ::std::string* mutable_url();
+  inline ::std::string* release_url();
+  inline void set_allocated_url(::std::string* url);
+
+  // optional string page_url = 2;
+  inline bool has_page_url() const;
+  inline void clear_page_url();
+  static const int kPageUrlFieldNumber = 2;
+  inline const ::std::string& page_url() const;
+  inline void set_page_url(const ::std::string& value);
+  inline void set_page_url(const char* value);
+  inline void set_page_url(const char* value, size_t size);
+  inline ::std::string* mutable_page_url();
+  inline ::std::string* release_page_url();
+  inline void set_allocated_page_url(::std::string* page_url);
+
+  // optional string referrer_url = 3;
+  inline bool has_referrer_url() const;
+  inline void clear_referrer_url();
+  static const int kReferrerUrlFieldNumber = 3;
+  inline const ::std::string& referrer_url() const;
+  inline void set_referrer_url(const ::std::string& value);
+  inline void set_referrer_url(const char* value);
+  inline void set_referrer_url(const char* value, size_t size);
+  inline ::std::string* mutable_referrer_url();
+  inline ::std::string* release_referrer_url();
+  inline void set_allocated_referrer_url(::std::string* referrer_url);
+
+  // repeated .safe_browsing.ClientSafeBrowsingReportRequest.Resource resources = 4;
+  inline int resources_size() const;
+  inline void clear_resources();
+  static const int kResourcesFieldNumber = 4;
+  inline const ::safe_browsing::ClientSafeBrowsingReportRequest_Resource& resources(int index) const;
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* mutable_resources(int index);
+  inline ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* add_resources();
+  inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource >&
+      resources() const;
+  inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource >*
+      mutable_resources();
+
+  // optional bool complete = 5;
+  inline bool has_complete() const;
+  inline void clear_complete();
+  static const int kCompleteFieldNumber = 5;
+  inline bool complete() const;
+  inline void set_complete(bool value);
+
+  // repeated string client_asn = 6;
+  inline int client_asn_size() const;
+  inline void clear_client_asn();
+  static const int kClientAsnFieldNumber = 6;
+  inline const ::std::string& client_asn(int index) const;
+  inline ::std::string* mutable_client_asn(int index);
+  inline void set_client_asn(int index, const ::std::string& value);
+  inline void set_client_asn(int index, const char* value);
+  inline void set_client_asn(int index, const char* value, size_t size);
+  inline ::std::string* add_client_asn();
+  inline void add_client_asn(const ::std::string& value);
+  inline void add_client_asn(const char* value);
+  inline void add_client_asn(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& client_asn() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_client_asn();
+
+  // optional string client_country = 7;
+  inline bool has_client_country() const;
+  inline void clear_client_country();
+  static const int kClientCountryFieldNumber = 7;
+  inline const ::std::string& client_country() const;
+  inline void set_client_country(const ::std::string& value);
+  inline void set_client_country(const char* value);
+  inline void set_client_country(const char* value, size_t size);
+  inline ::std::string* mutable_client_country();
+  inline ::std::string* release_client_country();
+  inline void set_allocated_client_country(::std::string* client_country);
+
+  // optional bool did_proceed = 8;
+  inline bool has_did_proceed() const;
+  inline void clear_did_proceed();
+  static const int kDidProceedFieldNumber = 8;
+  inline bool did_proceed() const;
+  inline void set_did_proceed(bool value);
+
+  // optional bool repeat_visit = 9;
+  inline bool has_repeat_visit() const;
+  inline void clear_repeat_visit();
+  static const int kRepeatVisitFieldNumber = 9;
+  inline bool repeat_visit() const;
+  inline void set_repeat_visit(bool value);
+
+  // optional bytes token = 15;
+  inline bool has_token() const;
+  inline void clear_token();
+  static const int kTokenFieldNumber = 15;
+  inline const ::std::string& token() const;
+  inline void set_token(const ::std::string& value);
+  inline void set_token(const char* value);
+  inline void set_token(const void* value, size_t size);
+  inline ::std::string* mutable_token();
+  inline ::std::string* release_token();
+  inline void set_allocated_token(::std::string* token);
+
+  // @@protoc_insertion_point(class_scope:safe_browsing.ClientSafeBrowsingReportRequest)
+ private:
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_download_verdict();
+  inline void clear_has_download_verdict();
+  inline void set_has_url();
+  inline void clear_has_url();
+  inline void set_has_page_url();
+  inline void clear_has_page_url();
+  inline void set_has_referrer_url();
+  inline void clear_has_referrer_url();
+  inline void set_has_complete();
+  inline void clear_has_complete();
+  inline void set_has_client_country();
+  inline void clear_has_client_country();
+  inline void set_has_did_proceed();
+  inline void clear_has_did_proceed();
+  inline void set_has_repeat_visit();
+  inline void clear_has_repeat_visit();
+  inline void set_has_token();
+  inline void clear_has_token();
+
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  int type_;
+  int download_verdict_;
+  ::std::string* url_;
+  ::std::string* page_url_;
+  ::std::string* referrer_url_;
+  ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource > resources_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> client_asn_;
+  ::std::string* client_country_;
+  ::std::string* token_;
+  bool complete_;
+  bool did_proceed_;
+  bool repeat_visit_;
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+  friend void protobuf_ShutdownFile_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientSafeBrowsingReportRequest* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+// ChromeUserPopulation
+
+// optional .safe_browsing.ChromeUserPopulation.UserPopulation user_population = 1;
+inline bool ChromeUserPopulation::has_user_population() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChromeUserPopulation::set_has_user_population() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChromeUserPopulation::clear_has_user_population() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChromeUserPopulation::clear_user_population() {
+  user_population_ = 0;
+  clear_has_user_population();
+}
+inline ::safe_browsing::ChromeUserPopulation_UserPopulation ChromeUserPopulation::user_population() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ChromeUserPopulation.user_population)
+  return static_cast< ::safe_browsing::ChromeUserPopulation_UserPopulation >(user_population_);
+}
+inline void ChromeUserPopulation::set_user_population(::safe_browsing::ChromeUserPopulation_UserPopulation value) {
+  assert(::safe_browsing::ChromeUserPopulation_UserPopulation_IsValid(value));
+  set_has_user_population();
+  user_population_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ChromeUserPopulation.user_population)
+}
+
+// -------------------------------------------------------------------
+
+// ClientPhishingRequest_Feature
+
+// required string name = 1;
+inline bool ClientPhishingRequest_Feature::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientPhishingRequest_Feature::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientPhishingRequest_Feature::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientPhishingRequest_Feature::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& ClientPhishingRequest_Feature::name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.Feature.name)
+  return *name_;
+}
+inline void ClientPhishingRequest_Feature::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.Feature.name)
+}
+inline void ClientPhishingRequest_Feature::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientPhishingRequest.Feature.name)
+}
+inline void ClientPhishingRequest_Feature::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientPhishingRequest.Feature.name)
+}
+inline ::std::string* ClientPhishingRequest_Feature::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.Feature.name)
+  return name_;
+}
+inline ::std::string* ClientPhishingRequest_Feature::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientPhishingRequest_Feature::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientPhishingRequest.Feature.name)
+}
+
+// required double value = 2;
+inline bool ClientPhishingRequest_Feature::has_value() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientPhishingRequest_Feature::set_has_value() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientPhishingRequest_Feature::clear_has_value() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientPhishingRequest_Feature::clear_value() {
+  value_ = 0;
+  clear_has_value();
+}
+inline double ClientPhishingRequest_Feature::value() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.Feature.value)
+  return value_;
+}
+inline void ClientPhishingRequest_Feature::set_value(double value) {
+  set_has_value();
+  value_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.Feature.value)
+}
+
+// -------------------------------------------------------------------
+
+// ClientPhishingRequest
+
+// optional string url = 1;
+inline bool ClientPhishingRequest::has_url() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientPhishingRequest::set_has_url() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientPhishingRequest::clear_has_url() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientPhishingRequest::clear_url() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_->clear();
+  }
+  clear_has_url();
+}
+inline const ::std::string& ClientPhishingRequest::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.url)
+  return *url_;
+}
+inline void ClientPhishingRequest::set_url(const ::std::string& value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.url)
+}
+inline void ClientPhishingRequest::set_url(const char* value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientPhishingRequest.url)
+}
+inline void ClientPhishingRequest::set_url(const char* value, size_t size) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientPhishingRequest.url)
+}
+inline ::std::string* ClientPhishingRequest::mutable_url() {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.url)
+  return url_;
+}
+inline ::std::string* ClientPhishingRequest::release_url() {
+  clear_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_;
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientPhishingRequest::set_allocated_url(::std::string* url) {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (url) {
+    set_has_url();
+    url_ = url;
+  } else {
+    clear_has_url();
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientPhishingRequest.url)
+}
+
+// optional bytes OBSOLETE_hash_prefix = 10;
+inline bool ClientPhishingRequest::has_obsolete_hash_prefix() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientPhishingRequest::set_has_obsolete_hash_prefix() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientPhishingRequest::clear_has_obsolete_hash_prefix() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientPhishingRequest::clear_obsolete_hash_prefix() {
+  if (obsolete_hash_prefix_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    obsolete_hash_prefix_->clear();
+  }
+  clear_has_obsolete_hash_prefix();
+}
+inline const ::std::string& ClientPhishingRequest::obsolete_hash_prefix() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix)
+  return *obsolete_hash_prefix_;
+}
+inline void ClientPhishingRequest::set_obsolete_hash_prefix(const ::std::string& value) {
+  set_has_obsolete_hash_prefix();
+  if (obsolete_hash_prefix_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    obsolete_hash_prefix_ = new ::std::string;
+  }
+  obsolete_hash_prefix_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix)
+}
+inline void ClientPhishingRequest::set_obsolete_hash_prefix(const char* value) {
+  set_has_obsolete_hash_prefix();
+  if (obsolete_hash_prefix_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    obsolete_hash_prefix_ = new ::std::string;
+  }
+  obsolete_hash_prefix_->assign(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) {
+  set_has_obsolete_hash_prefix();
+  if (obsolete_hash_prefix_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    obsolete_hash_prefix_ = new ::std::string;
+  }
+  obsolete_hash_prefix_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix)
+}
+inline ::std::string* ClientPhishingRequest::mutable_obsolete_hash_prefix() {
+  set_has_obsolete_hash_prefix();
+  if (obsolete_hash_prefix_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    obsolete_hash_prefix_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix)
+  return obsolete_hash_prefix_;
+}
+inline ::std::string* ClientPhishingRequest::release_obsolete_hash_prefix() {
+  clear_has_obsolete_hash_prefix();
+  if (obsolete_hash_prefix_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = obsolete_hash_prefix_;
+    obsolete_hash_prefix_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientPhishingRequest::set_allocated_obsolete_hash_prefix(::std::string* obsolete_hash_prefix) {
+  if (obsolete_hash_prefix_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete obsolete_hash_prefix_;
+  }
+  if (obsolete_hash_prefix) {
+    set_has_obsolete_hash_prefix();
+    obsolete_hash_prefix_ = obsolete_hash_prefix;
+  } else {
+    clear_has_obsolete_hash_prefix();
+    obsolete_hash_prefix_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientPhishingRequest.OBSOLETE_hash_prefix)
+}
+
+// required float client_score = 2;
+inline bool ClientPhishingRequest::has_client_score() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientPhishingRequest::set_has_client_score() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientPhishingRequest::clear_has_client_score() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientPhishingRequest::clear_client_score() {
+  client_score_ = 0;
+  clear_has_client_score();
+}
+inline float ClientPhishingRequest::client_score() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.client_score)
+  return client_score_;
+}
+inline void ClientPhishingRequest::set_client_score(float value) {
+  set_has_client_score();
+  client_score_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.client_score)
+}
+
+// optional bool is_phishing = 4;
+inline bool ClientPhishingRequest::has_is_phishing() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientPhishingRequest::set_has_is_phishing() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientPhishingRequest::clear_has_is_phishing() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientPhishingRequest::clear_is_phishing() {
+  is_phishing_ = false;
+  clear_has_is_phishing();
+}
+inline bool ClientPhishingRequest::is_phishing() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.is_phishing)
+  return is_phishing_;
+}
+inline void ClientPhishingRequest::set_is_phishing(bool value) {
+  set_has_is_phishing();
+  is_phishing_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.is_phishing)
+}
+
+// repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5;
+inline int ClientPhishingRequest::feature_map_size() const {
+  return feature_map_.size();
+}
+inline void ClientPhishingRequest::clear_feature_map() {
+  feature_map_.Clear();
+}
+inline const ::safe_browsing::ClientPhishingRequest_Feature& ClientPhishingRequest::feature_map(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.feature_map)
+  return feature_map_.Get(index);
+}
+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 ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::add_feature_map() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientPhishingRequest.feature_map)
+  return feature_map_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >&
+ClientPhishingRequest::feature_map() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientPhishingRequest.feature_map)
+  return feature_map_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >*
+ClientPhishingRequest::mutable_feature_map() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientPhishingRequest.feature_map)
+  return &feature_map_;
+}
+
+// optional int32 model_version = 6;
+inline bool ClientPhishingRequest::has_model_version() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClientPhishingRequest::set_has_model_version() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClientPhishingRequest::clear_has_model_version() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClientPhishingRequest::clear_model_version() {
+  model_version_ = 0;
+  clear_has_model_version();
+}
+inline ::google::protobuf::int32 ClientPhishingRequest::model_version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.model_version)
+  return model_version_;
+}
+inline void ClientPhishingRequest::set_model_version(::google::protobuf::int32 value) {
+  set_has_model_version();
+  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::non_model_feature_map_size() const {
+  return non_model_feature_map_.size();
+}
+inline void ClientPhishingRequest::clear_non_model_feature_map() {
+  non_model_feature_map_.Clear();
+}
+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 non_model_feature_map_.Get(index);
+}
+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 ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::add_non_model_feature_map() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientPhishingRequest.non_model_feature_map)
+  return non_model_feature_map_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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_;
+}
+
+// optional string OBSOLETE_referrer_url = 9;
+inline bool ClientPhishingRequest::has_obsolete_referrer_url() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClientPhishingRequest::set_has_obsolete_referrer_url() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClientPhishingRequest::clear_has_obsolete_referrer_url() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClientPhishingRequest::clear_obsolete_referrer_url() {
+  if (obsolete_referrer_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    obsolete_referrer_url_->clear();
+  }
+  clear_has_obsolete_referrer_url();
+}
+inline const ::std::string& ClientPhishingRequest::obsolete_referrer_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url)
+  return *obsolete_referrer_url_;
+}
+inline void ClientPhishingRequest::set_obsolete_referrer_url(const ::std::string& value) {
+  set_has_obsolete_referrer_url();
+  if (obsolete_referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    obsolete_referrer_url_ = new ::std::string;
+  }
+  obsolete_referrer_url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url)
+}
+inline void ClientPhishingRequest::set_obsolete_referrer_url(const char* value) {
+  set_has_obsolete_referrer_url();
+  if (obsolete_referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    obsolete_referrer_url_ = new ::std::string;
+  }
+  obsolete_referrer_url_->assign(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) {
+  set_has_obsolete_referrer_url();
+  if (obsolete_referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    obsolete_referrer_url_ = new ::std::string;
+  }
+  obsolete_referrer_url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url)
+}
+inline ::std::string* ClientPhishingRequest::mutable_obsolete_referrer_url() {
+  set_has_obsolete_referrer_url();
+  if (obsolete_referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    obsolete_referrer_url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url)
+  return obsolete_referrer_url_;
+}
+inline ::std::string* ClientPhishingRequest::release_obsolete_referrer_url() {
+  clear_has_obsolete_referrer_url();
+  if (obsolete_referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = obsolete_referrer_url_;
+    obsolete_referrer_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientPhishingRequest::set_allocated_obsolete_referrer_url(::std::string* obsolete_referrer_url) {
+  if (obsolete_referrer_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete obsolete_referrer_url_;
+  }
+  if (obsolete_referrer_url) {
+    set_has_obsolete_referrer_url();
+    obsolete_referrer_url_ = obsolete_referrer_url;
+  } else {
+    clear_has_obsolete_referrer_url();
+    obsolete_referrer_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientPhishingRequest.OBSOLETE_referrer_url)
+}
+
+// repeated uint32 shingle_hashes = 12 [packed = true];
+inline int ClientPhishingRequest::shingle_hashes_size() const {
+  return shingle_hashes_.size();
+}
+inline void ClientPhishingRequest::clear_shingle_hashes() {
+  shingle_hashes_.Clear();
+}
+inline ::google::protobuf::uint32 ClientPhishingRequest::shingle_hashes(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.shingle_hashes)
+  return shingle_hashes_.Get(index);
+}
+inline void ClientPhishingRequest::set_shingle_hashes(int index, ::google::protobuf::uint32 value) {
+  shingle_hashes_.Set(index, value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.shingle_hashes)
+}
+inline void ClientPhishingRequest::add_shingle_hashes(::google::protobuf::uint32 value) {
+  shingle_hashes_.Add(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientPhishingRequest.shingle_hashes)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+ClientPhishingRequest::shingle_hashes() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientPhishingRequest.shingle_hashes)
+  return shingle_hashes_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+ClientPhishingRequest::mutable_shingle_hashes() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientPhishingRequest.shingle_hashes)
+  return &shingle_hashes_;
+}
+
+// optional string model_filename = 13;
+inline bool ClientPhishingRequest::has_model_filename() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void ClientPhishingRequest::set_has_model_filename() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void ClientPhishingRequest::clear_has_model_filename() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void ClientPhishingRequest::clear_model_filename() {
+  if (model_filename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    model_filename_->clear();
+  }
+  clear_has_model_filename();
+}
+inline const ::std::string& ClientPhishingRequest::model_filename() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.model_filename)
+  return *model_filename_;
+}
+inline void ClientPhishingRequest::set_model_filename(const ::std::string& value) {
+  set_has_model_filename();
+  if (model_filename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    model_filename_ = new ::std::string;
+  }
+  model_filename_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingRequest.model_filename)
+}
+inline void ClientPhishingRequest::set_model_filename(const char* value) {
+  set_has_model_filename();
+  if (model_filename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    model_filename_ = new ::std::string;
+  }
+  model_filename_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientPhishingRequest.model_filename)
+}
+inline void ClientPhishingRequest::set_model_filename(const char* value, size_t size) {
+  set_has_model_filename();
+  if (model_filename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    model_filename_ = new ::std::string;
+  }
+  model_filename_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientPhishingRequest.model_filename)
+}
+inline ::std::string* ClientPhishingRequest::mutable_model_filename() {
+  set_has_model_filename();
+  if (model_filename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    model_filename_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.model_filename)
+  return model_filename_;
+}
+inline ::std::string* ClientPhishingRequest::release_model_filename() {
+  clear_has_model_filename();
+  if (model_filename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = model_filename_;
+    model_filename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientPhishingRequest::set_allocated_model_filename(::std::string* model_filename) {
+  if (model_filename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete model_filename_;
+  }
+  if (model_filename) {
+    set_has_model_filename();
+    model_filename_ = model_filename;
+  } else {
+    clear_has_model_filename();
+    model_filename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientPhishingRequest.model_filename)
+}
+
+// optional .safe_browsing.ChromeUserPopulation population = 14;
+inline bool ClientPhishingRequest::has_population() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void ClientPhishingRequest::set_has_population() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void ClientPhishingRequest::clear_has_population() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void ClientPhishingRequest::clear_population() {
+  if (population_ != NULL) population_->::safe_browsing::ChromeUserPopulation::Clear();
+  clear_has_population();
+}
+inline const ::safe_browsing::ChromeUserPopulation& ClientPhishingRequest::population() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingRequest.population)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return population_ != NULL ? *population_ : *default_instance().population_;
+#else
+  return population_ != NULL ? *population_ : *default_instance_->population_;
+#endif
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientPhishingRequest::mutable_population() {
+  set_has_population();
+  if (population_ == NULL) population_ = new ::safe_browsing::ChromeUserPopulation;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientPhishingRequest.population)
+  return population_;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientPhishingRequest::release_population() {
+  clear_has_population();
+  ::safe_browsing::ChromeUserPopulation* temp = population_;
+  population_ = NULL;
+  return temp;
+}
+inline void ClientPhishingRequest::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) {
+  delete population_;
+  population_ = population;
+  if (population) {
+    set_has_population();
+  } else {
+    clear_has_population();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientPhishingRequest.population)
+}
+
+// -------------------------------------------------------------------
+
+// ClientPhishingResponse
+
+// required bool phishy = 1;
+inline bool ClientPhishingResponse::has_phishy() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientPhishingResponse::set_has_phishy() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientPhishingResponse::clear_has_phishy() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientPhishingResponse::clear_phishy() {
+  phishy_ = false;
+  clear_has_phishy();
+}
+inline bool ClientPhishingResponse::phishy() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingResponse.phishy)
+  return phishy_;
+}
+inline void ClientPhishingResponse::set_phishy(bool value) {
+  set_has_phishy();
+  phishy_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientPhishingResponse.phishy)
+}
+
+// repeated string OBSOLETE_whitelist_expression = 2;
+inline int ClientPhishingResponse::obsolete_whitelist_expression_size() const {
+  return obsolete_whitelist_expression_.size();
+}
+inline void ClientPhishingResponse::clear_obsolete_whitelist_expression() {
+  obsolete_whitelist_expression_.Clear();
+}
+inline const ::std::string& ClientPhishingResponse::obsolete_whitelist_expression(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+  return obsolete_whitelist_expression_.Get(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, const char* value) {
+  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::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(const char* value) {
+  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 ::google::protobuf::RepeatedPtrField< ::std::string>&
+ClientPhishingResponse::obsolete_whitelist_expression() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientPhishingResponse.OBSOLETE_whitelist_expression)
+  return obsolete_whitelist_expression_;
+}
+inline ::google::protobuf::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::has_ip() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientMalwareRequest_UrlInfo::set_has_ip() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientMalwareRequest_UrlInfo::clear_has_ip() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientMalwareRequest_UrlInfo::clear_ip() {
+  if (ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_->clear();
+  }
+  clear_has_ip();
+}
+inline const ::std::string& ClientMalwareRequest_UrlInfo::ip() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.UrlInfo.ip)
+  return *ip_;
+}
+inline void ClientMalwareRequest_UrlInfo::set_ip(const ::std::string& value) {
+  set_has_ip();
+  if (ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_ = new ::std::string;
+  }
+  ip_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.ip)
+}
+inline void ClientMalwareRequest_UrlInfo::set_ip(const char* value) {
+  set_has_ip();
+  if (ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_ = new ::std::string;
+  }
+  ip_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareRequest.UrlInfo.ip)
+}
+inline void ClientMalwareRequest_UrlInfo::set_ip(const char* value, size_t size) {
+  set_has_ip();
+  if (ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_ = new ::std::string;
+  }
+  ip_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareRequest.UrlInfo.ip)
+}
+inline ::std::string* ClientMalwareRequest_UrlInfo::mutable_ip() {
+  set_has_ip();
+  if (ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.UrlInfo.ip)
+  return ip_;
+}
+inline ::std::string* ClientMalwareRequest_UrlInfo::release_ip() {
+  clear_has_ip();
+  if (ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = ip_;
+    ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientMalwareRequest_UrlInfo::set_allocated_ip(::std::string* ip) {
+  if (ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete ip_;
+  }
+  if (ip) {
+    set_has_ip();
+    ip_ = ip;
+  } else {
+    clear_has_ip();
+    ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.UrlInfo.ip)
+}
+
+// required string url = 2;
+inline bool ClientMalwareRequest_UrlInfo::has_url() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientMalwareRequest_UrlInfo::set_has_url() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientMalwareRequest_UrlInfo::clear_has_url() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientMalwareRequest_UrlInfo::clear_url() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_->clear();
+  }
+  clear_has_url();
+}
+inline const ::std::string& ClientMalwareRequest_UrlInfo::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.UrlInfo.url)
+  return *url_;
+}
+inline void ClientMalwareRequest_UrlInfo::set_url(const ::std::string& value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.url)
+}
+inline void ClientMalwareRequest_UrlInfo::set_url(const char* value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareRequest.UrlInfo.url)
+}
+inline void ClientMalwareRequest_UrlInfo::set_url(const char* value, size_t size) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareRequest.UrlInfo.url)
+}
+inline ::std::string* ClientMalwareRequest_UrlInfo::mutable_url() {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.UrlInfo.url)
+  return url_;
+}
+inline ::std::string* ClientMalwareRequest_UrlInfo::release_url() {
+  clear_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_;
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientMalwareRequest_UrlInfo::set_allocated_url(::std::string* url) {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (url) {
+    set_has_url();
+    url_ = url;
+  } else {
+    clear_has_url();
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.UrlInfo.url)
+}
+
+// optional string method = 3;
+inline bool ClientMalwareRequest_UrlInfo::has_method() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientMalwareRequest_UrlInfo::set_has_method() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientMalwareRequest_UrlInfo::clear_has_method() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientMalwareRequest_UrlInfo::clear_method() {
+  if (method_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    method_->clear();
+  }
+  clear_has_method();
+}
+inline const ::std::string& ClientMalwareRequest_UrlInfo::method() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.UrlInfo.method)
+  return *method_;
+}
+inline void ClientMalwareRequest_UrlInfo::set_method(const ::std::string& value) {
+  set_has_method();
+  if (method_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    method_ = new ::std::string;
+  }
+  method_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.method)
+}
+inline void ClientMalwareRequest_UrlInfo::set_method(const char* value) {
+  set_has_method();
+  if (method_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    method_ = new ::std::string;
+  }
+  method_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareRequest.UrlInfo.method)
+}
+inline void ClientMalwareRequest_UrlInfo::set_method(const char* value, size_t size) {
+  set_has_method();
+  if (method_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    method_ = new ::std::string;
+  }
+  method_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareRequest.UrlInfo.method)
+}
+inline ::std::string* ClientMalwareRequest_UrlInfo::mutable_method() {
+  set_has_method();
+  if (method_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    method_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.UrlInfo.method)
+  return method_;
+}
+inline ::std::string* ClientMalwareRequest_UrlInfo::release_method() {
+  clear_has_method();
+  if (method_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = method_;
+    method_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientMalwareRequest_UrlInfo::set_allocated_method(::std::string* method) {
+  if (method_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete method_;
+  }
+  if (method) {
+    set_has_method();
+    method_ = method;
+  } else {
+    clear_has_method();
+    method_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.UrlInfo.method)
+}
+
+// optional string referrer = 4;
+inline bool ClientMalwareRequest_UrlInfo::has_referrer() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientMalwareRequest_UrlInfo::set_has_referrer() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientMalwareRequest_UrlInfo::clear_has_referrer() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientMalwareRequest_UrlInfo::clear_referrer() {
+  if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_->clear();
+  }
+  clear_has_referrer();
+}
+inline const ::std::string& ClientMalwareRequest_UrlInfo::referrer() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.UrlInfo.referrer)
+  return *referrer_;
+}
+inline void ClientMalwareRequest_UrlInfo::set_referrer(const ::std::string& value) {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  referrer_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.referrer)
+}
+inline void ClientMalwareRequest_UrlInfo::set_referrer(const char* value) {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  referrer_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareRequest.UrlInfo.referrer)
+}
+inline void ClientMalwareRequest_UrlInfo::set_referrer(const char* value, size_t size) {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  referrer_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareRequest.UrlInfo.referrer)
+}
+inline ::std::string* ClientMalwareRequest_UrlInfo::mutable_referrer() {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.UrlInfo.referrer)
+  return referrer_;
+}
+inline ::std::string* ClientMalwareRequest_UrlInfo::release_referrer() {
+  clear_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = referrer_;
+    referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientMalwareRequest_UrlInfo::set_allocated_referrer(::std::string* referrer) {
+  if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete referrer_;
+  }
+  if (referrer) {
+    set_has_referrer();
+    referrer_ = referrer;
+  } else {
+    clear_has_referrer();
+    referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.UrlInfo.referrer)
+}
+
+// optional int32 resource_type = 5;
+inline bool ClientMalwareRequest_UrlInfo::has_resource_type() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientMalwareRequest_UrlInfo::set_has_resource_type() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientMalwareRequest_UrlInfo::clear_has_resource_type() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientMalwareRequest_UrlInfo::clear_resource_type() {
+  resource_type_ = 0;
+  clear_has_resource_type();
+}
+inline ::google::protobuf::int32 ClientMalwareRequest_UrlInfo::resource_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.UrlInfo.resource_type)
+  return resource_type_;
+}
+inline void ClientMalwareRequest_UrlInfo::set_resource_type(::google::protobuf::int32 value) {
+  set_has_resource_type();
+  resource_type_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.UrlInfo.resource_type)
+}
+
+// -------------------------------------------------------------------
+
+// ClientMalwareRequest
+
+// required string url = 1;
+inline bool ClientMalwareRequest::has_url() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientMalwareRequest::set_has_url() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientMalwareRequest::clear_has_url() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientMalwareRequest::clear_url() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_->clear();
+  }
+  clear_has_url();
+}
+inline const ::std::string& ClientMalwareRequest::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.url)
+  return *url_;
+}
+inline void ClientMalwareRequest::set_url(const ::std::string& value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.url)
+}
+inline void ClientMalwareRequest::set_url(const char* value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareRequest.url)
+}
+inline void ClientMalwareRequest::set_url(const char* value, size_t size) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareRequest.url)
+}
+inline ::std::string* ClientMalwareRequest::mutable_url() {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.url)
+  return url_;
+}
+inline ::std::string* ClientMalwareRequest::release_url() {
+  clear_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_;
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientMalwareRequest::set_allocated_url(::std::string* url) {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (url) {
+    set_has_url();
+    url_ = url;
+  } else {
+    clear_has_url();
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.url)
+}
+
+// optional string referrer_url = 4;
+inline bool ClientMalwareRequest::has_referrer_url() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientMalwareRequest::set_has_referrer_url() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientMalwareRequest::clear_has_referrer_url() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientMalwareRequest::clear_referrer_url() {
+  if (referrer_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_url_->clear();
+  }
+  clear_has_referrer_url();
+}
+inline const ::std::string& ClientMalwareRequest::referrer_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.referrer_url)
+  return *referrer_url_;
+}
+inline void ClientMalwareRequest::set_referrer_url(const ::std::string& value) {
+  set_has_referrer_url();
+  if (referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_url_ = new ::std::string;
+  }
+  referrer_url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareRequest.referrer_url)
+}
+inline void ClientMalwareRequest::set_referrer_url(const char* value) {
+  set_has_referrer_url();
+  if (referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_url_ = new ::std::string;
+  }
+  referrer_url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareRequest.referrer_url)
+}
+inline void ClientMalwareRequest::set_referrer_url(const char* value, size_t size) {
+  set_has_referrer_url();
+  if (referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_url_ = new ::std::string;
+  }
+  referrer_url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareRequest.referrer_url)
+}
+inline ::std::string* ClientMalwareRequest::mutable_referrer_url() {
+  set_has_referrer_url();
+  if (referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.referrer_url)
+  return referrer_url_;
+}
+inline ::std::string* ClientMalwareRequest::release_referrer_url() {
+  clear_has_referrer_url();
+  if (referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = referrer_url_;
+    referrer_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientMalwareRequest::set_allocated_referrer_url(::std::string* referrer_url) {
+  if (referrer_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete referrer_url_;
+  }
+  if (referrer_url) {
+    set_has_referrer_url();
+    referrer_url_ = referrer_url;
+  } else {
+    clear_has_referrer_url();
+    referrer_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.referrer_url)
+}
+
+// repeated .safe_browsing.ClientMalwareRequest.UrlInfo bad_ip_url_info = 7;
+inline int ClientMalwareRequest::bad_ip_url_info_size() const {
+  return bad_ip_url_info_.size();
+}
+inline void ClientMalwareRequest::clear_bad_ip_url_info() {
+  bad_ip_url_info_.Clear();
+}
+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 bad_ip_url_info_.Get(index);
+}
+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 ::safe_browsing::ClientMalwareRequest_UrlInfo* ClientMalwareRequest::add_bad_ip_url_info() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientMalwareRequest.bad_ip_url_info)
+  return bad_ip_url_info_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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_;
+}
+
+// optional .safe_browsing.ChromeUserPopulation population = 9;
+inline bool ClientMalwareRequest::has_population() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientMalwareRequest::set_has_population() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientMalwareRequest::clear_has_population() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientMalwareRequest::clear_population() {
+  if (population_ != NULL) population_->::safe_browsing::ChromeUserPopulation::Clear();
+  clear_has_population();
+}
+inline const ::safe_browsing::ChromeUserPopulation& ClientMalwareRequest::population() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareRequest.population)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return population_ != NULL ? *population_ : *default_instance().population_;
+#else
+  return population_ != NULL ? *population_ : *default_instance_->population_;
+#endif
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientMalwareRequest::mutable_population() {
+  set_has_population();
+  if (population_ == NULL) population_ = new ::safe_browsing::ChromeUserPopulation;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareRequest.population)
+  return population_;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientMalwareRequest::release_population() {
+  clear_has_population();
+  ::safe_browsing::ChromeUserPopulation* temp = population_;
+  population_ = NULL;
+  return temp;
+}
+inline void ClientMalwareRequest::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) {
+  delete population_;
+  population_ = population;
+  if (population) {
+    set_has_population();
+  } else {
+    clear_has_population();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareRequest.population)
+}
+
+// -------------------------------------------------------------------
+
+// ClientMalwareResponse
+
+// required bool blacklist = 1;
+inline bool ClientMalwareResponse::has_blacklist() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientMalwareResponse::set_has_blacklist() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientMalwareResponse::clear_has_blacklist() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientMalwareResponse::clear_blacklist() {
+  blacklist_ = false;
+  clear_has_blacklist();
+}
+inline bool ClientMalwareResponse::blacklist() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareResponse.blacklist)
+  return blacklist_;
+}
+inline void ClientMalwareResponse::set_blacklist(bool value) {
+  set_has_blacklist();
+  blacklist_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareResponse.blacklist)
+}
+
+// optional string bad_ip = 2;
+inline bool ClientMalwareResponse::has_bad_ip() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientMalwareResponse::set_has_bad_ip() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientMalwareResponse::clear_has_bad_ip() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientMalwareResponse::clear_bad_ip() {
+  if (bad_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bad_ip_->clear();
+  }
+  clear_has_bad_ip();
+}
+inline const ::std::string& ClientMalwareResponse::bad_ip() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareResponse.bad_ip)
+  return *bad_ip_;
+}
+inline void ClientMalwareResponse::set_bad_ip(const ::std::string& value) {
+  set_has_bad_ip();
+  if (bad_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bad_ip_ = new ::std::string;
+  }
+  bad_ip_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareResponse.bad_ip)
+}
+inline void ClientMalwareResponse::set_bad_ip(const char* value) {
+  set_has_bad_ip();
+  if (bad_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bad_ip_ = new ::std::string;
+  }
+  bad_ip_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareResponse.bad_ip)
+}
+inline void ClientMalwareResponse::set_bad_ip(const char* value, size_t size) {
+  set_has_bad_ip();
+  if (bad_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bad_ip_ = new ::std::string;
+  }
+  bad_ip_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareResponse.bad_ip)
+}
+inline ::std::string* ClientMalwareResponse::mutable_bad_ip() {
+  set_has_bad_ip();
+  if (bad_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bad_ip_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareResponse.bad_ip)
+  return bad_ip_;
+}
+inline ::std::string* ClientMalwareResponse::release_bad_ip() {
+  clear_has_bad_ip();
+  if (bad_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = bad_ip_;
+    bad_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientMalwareResponse::set_allocated_bad_ip(::std::string* bad_ip) {
+  if (bad_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete bad_ip_;
+  }
+  if (bad_ip) {
+    set_has_bad_ip();
+    bad_ip_ = bad_ip;
+  } else {
+    clear_has_bad_ip();
+    bad_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareResponse.bad_ip)
+}
+
+// optional string bad_url = 3;
+inline bool ClientMalwareResponse::has_bad_url() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientMalwareResponse::set_has_bad_url() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientMalwareResponse::clear_has_bad_url() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientMalwareResponse::clear_bad_url() {
+  if (bad_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bad_url_->clear();
+  }
+  clear_has_bad_url();
+}
+inline const ::std::string& ClientMalwareResponse::bad_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientMalwareResponse.bad_url)
+  return *bad_url_;
+}
+inline void ClientMalwareResponse::set_bad_url(const ::std::string& value) {
+  set_has_bad_url();
+  if (bad_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bad_url_ = new ::std::string;
+  }
+  bad_url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientMalwareResponse.bad_url)
+}
+inline void ClientMalwareResponse::set_bad_url(const char* value) {
+  set_has_bad_url();
+  if (bad_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bad_url_ = new ::std::string;
+  }
+  bad_url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientMalwareResponse.bad_url)
+}
+inline void ClientMalwareResponse::set_bad_url(const char* value, size_t size) {
+  set_has_bad_url();
+  if (bad_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bad_url_ = new ::std::string;
+  }
+  bad_url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientMalwareResponse.bad_url)
+}
+inline ::std::string* ClientMalwareResponse::mutable_bad_url() {
+  set_has_bad_url();
+  if (bad_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bad_url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientMalwareResponse.bad_url)
+  return bad_url_;
+}
+inline ::std::string* ClientMalwareResponse::release_bad_url() {
+  clear_has_bad_url();
+  if (bad_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = bad_url_;
+    bad_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientMalwareResponse::set_allocated_bad_url(::std::string* bad_url) {
+  if (bad_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete bad_url_;
+  }
+  if (bad_url) {
+    set_has_bad_url();
+    bad_url_ = bad_url;
+  } else {
+    clear_has_bad_url();
+    bad_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientMalwareResponse.bad_url)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_Digests
+
+// optional bytes sha256 = 1;
+inline bool ClientDownloadRequest_Digests::has_sha256() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadRequest_Digests::set_has_sha256() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadRequest_Digests::clear_has_sha256() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadRequest_Digests::clear_sha256() {
+  if (sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha256_->clear();
+  }
+  clear_has_sha256();
+}
+inline const ::std::string& ClientDownloadRequest_Digests::sha256() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Digests.sha256)
+  return *sha256_;
+}
+inline void ClientDownloadRequest_Digests::set_sha256(const ::std::string& value) {
+  set_has_sha256();
+  if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha256_ = new ::std::string;
+  }
+  sha256_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Digests.sha256)
+}
+inline void ClientDownloadRequest_Digests::set_sha256(const char* value) {
+  set_has_sha256();
+  if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha256_ = new ::std::string;
+  }
+  sha256_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.Digests.sha256)
+}
+inline void ClientDownloadRequest_Digests::set_sha256(const void* value, size_t size) {
+  set_has_sha256();
+  if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha256_ = new ::std::string;
+  }
+  sha256_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.Digests.sha256)
+}
+inline ::std::string* ClientDownloadRequest_Digests::mutable_sha256() {
+  set_has_sha256();
+  if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha256_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Digests.sha256)
+  return sha256_;
+}
+inline ::std::string* ClientDownloadRequest_Digests::release_sha256() {
+  clear_has_sha256();
+  if (sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = sha256_;
+    sha256_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_Digests::set_allocated_sha256(::std::string* sha256) {
+  if (sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete sha256_;
+  }
+  if (sha256) {
+    set_has_sha256();
+    sha256_ = sha256;
+  } else {
+    clear_has_sha256();
+    sha256_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.Digests.sha256)
+}
+
+// optional bytes sha1 = 2;
+inline bool ClientDownloadRequest_Digests::has_sha1() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientDownloadRequest_Digests::set_has_sha1() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientDownloadRequest_Digests::clear_has_sha1() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientDownloadRequest_Digests::clear_sha1() {
+  if (sha1_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha1_->clear();
+  }
+  clear_has_sha1();
+}
+inline const ::std::string& ClientDownloadRequest_Digests::sha1() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Digests.sha1)
+  return *sha1_;
+}
+inline void ClientDownloadRequest_Digests::set_sha1(const ::std::string& value) {
+  set_has_sha1();
+  if (sha1_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha1_ = new ::std::string;
+  }
+  sha1_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Digests.sha1)
+}
+inline void ClientDownloadRequest_Digests::set_sha1(const char* value) {
+  set_has_sha1();
+  if (sha1_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha1_ = new ::std::string;
+  }
+  sha1_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.Digests.sha1)
+}
+inline void ClientDownloadRequest_Digests::set_sha1(const void* value, size_t size) {
+  set_has_sha1();
+  if (sha1_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha1_ = new ::std::string;
+  }
+  sha1_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.Digests.sha1)
+}
+inline ::std::string* ClientDownloadRequest_Digests::mutable_sha1() {
+  set_has_sha1();
+  if (sha1_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sha1_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Digests.sha1)
+  return sha1_;
+}
+inline ::std::string* ClientDownloadRequest_Digests::release_sha1() {
+  clear_has_sha1();
+  if (sha1_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = sha1_;
+    sha1_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_Digests::set_allocated_sha1(::std::string* sha1) {
+  if (sha1_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete sha1_;
+  }
+  if (sha1) {
+    set_has_sha1();
+    sha1_ = sha1;
+  } else {
+    clear_has_sha1();
+    sha1_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.Digests.sha1)
+}
+
+// optional bytes md5 = 3;
+inline bool ClientDownloadRequest_Digests::has_md5() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientDownloadRequest_Digests::set_has_md5() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientDownloadRequest_Digests::clear_has_md5() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientDownloadRequest_Digests::clear_md5() {
+  if (md5_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    md5_->clear();
+  }
+  clear_has_md5();
+}
+inline const ::std::string& ClientDownloadRequest_Digests::md5() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Digests.md5)
+  return *md5_;
+}
+inline void ClientDownloadRequest_Digests::set_md5(const ::std::string& value) {
+  set_has_md5();
+  if (md5_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    md5_ = new ::std::string;
+  }
+  md5_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Digests.md5)
+}
+inline void ClientDownloadRequest_Digests::set_md5(const char* value) {
+  set_has_md5();
+  if (md5_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    md5_ = new ::std::string;
+  }
+  md5_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.Digests.md5)
+}
+inline void ClientDownloadRequest_Digests::set_md5(const void* value, size_t size) {
+  set_has_md5();
+  if (md5_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    md5_ = new ::std::string;
+  }
+  md5_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.Digests.md5)
+}
+inline ::std::string* ClientDownloadRequest_Digests::mutable_md5() {
+  set_has_md5();
+  if (md5_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    md5_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Digests.md5)
+  return md5_;
+}
+inline ::std::string* ClientDownloadRequest_Digests::release_md5() {
+  clear_has_md5();
+  if (md5_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = md5_;
+    md5_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_Digests::set_allocated_md5(::std::string* md5) {
+  if (md5_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete md5_;
+  }
+  if (md5) {
+    set_has_md5();
+    md5_ = md5;
+  } else {
+    clear_has_md5();
+    md5_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.Digests.md5)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_Resource
+
+// required string url = 1;
+inline bool ClientDownloadRequest_Resource::has_url() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadRequest_Resource::set_has_url() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadRequest_Resource::clear_has_url() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadRequest_Resource::clear_url() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_->clear();
+  }
+  clear_has_url();
+}
+inline const ::std::string& ClientDownloadRequest_Resource::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Resource.url)
+  return *url_;
+}
+inline void ClientDownloadRequest_Resource::set_url(const ::std::string& value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Resource.url)
+}
+inline void ClientDownloadRequest_Resource::set_url(const char* value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.Resource.url)
+}
+inline void ClientDownloadRequest_Resource::set_url(const char* value, size_t size) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.Resource.url)
+}
+inline ::std::string* ClientDownloadRequest_Resource::mutable_url() {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Resource.url)
+  return url_;
+}
+inline ::std::string* ClientDownloadRequest_Resource::release_url() {
+  clear_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_;
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_Resource::set_allocated_url(::std::string* url) {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (url) {
+    set_has_url();
+    url_ = url;
+  } else {
+    clear_has_url();
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.Resource.url)
+}
+
+// required .safe_browsing.ClientDownloadRequest.ResourceType type = 2;
+inline bool ClientDownloadRequest_Resource::has_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientDownloadRequest_Resource::set_has_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientDownloadRequest_Resource::clear_has_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientDownloadRequest_Resource::clear_type() {
+  type_ = 0;
+  clear_has_type();
+}
+inline ::safe_browsing::ClientDownloadRequest_ResourceType ClientDownloadRequest_Resource::type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Resource.type)
+  return static_cast< ::safe_browsing::ClientDownloadRequest_ResourceType >(type_);
+}
+inline void ClientDownloadRequest_Resource::set_type(::safe_browsing::ClientDownloadRequest_ResourceType value) {
+  assert(::safe_browsing::ClientDownloadRequest_ResourceType_IsValid(value));
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Resource.type)
+}
+
+// optional bytes remote_ip = 3;
+inline bool ClientDownloadRequest_Resource::has_remote_ip() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientDownloadRequest_Resource::set_has_remote_ip() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientDownloadRequest_Resource::clear_has_remote_ip() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientDownloadRequest_Resource::clear_remote_ip() {
+  if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_->clear();
+  }
+  clear_has_remote_ip();
+}
+inline const ::std::string& ClientDownloadRequest_Resource::remote_ip() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Resource.remote_ip)
+  return *remote_ip_;
+}
+inline void ClientDownloadRequest_Resource::set_remote_ip(const ::std::string& value) {
+  set_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_ = new ::std::string;
+  }
+  remote_ip_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Resource.remote_ip)
+}
+inline void ClientDownloadRequest_Resource::set_remote_ip(const char* value) {
+  set_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_ = new ::std::string;
+  }
+  remote_ip_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.Resource.remote_ip)
+}
+inline void ClientDownloadRequest_Resource::set_remote_ip(const void* value, size_t size) {
+  set_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_ = new ::std::string;
+  }
+  remote_ip_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.Resource.remote_ip)
+}
+inline ::std::string* ClientDownloadRequest_Resource::mutable_remote_ip() {
+  set_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Resource.remote_ip)
+  return remote_ip_;
+}
+inline ::std::string* ClientDownloadRequest_Resource::release_remote_ip() {
+  clear_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = remote_ip_;
+    remote_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_Resource::set_allocated_remote_ip(::std::string* remote_ip) {
+  if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete remote_ip_;
+  }
+  if (remote_ip) {
+    set_has_remote_ip();
+    remote_ip_ = remote_ip;
+  } else {
+    clear_has_remote_ip();
+    remote_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.Resource.remote_ip)
+}
+
+// optional string referrer = 4;
+inline bool ClientDownloadRequest_Resource::has_referrer() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientDownloadRequest_Resource::set_has_referrer() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientDownloadRequest_Resource::clear_has_referrer() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientDownloadRequest_Resource::clear_referrer() {
+  if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_->clear();
+  }
+  clear_has_referrer();
+}
+inline const ::std::string& ClientDownloadRequest_Resource::referrer() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.Resource.referrer)
+  return *referrer_;
+}
+inline void ClientDownloadRequest_Resource::set_referrer(const ::std::string& value) {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  referrer_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.Resource.referrer)
+}
+inline void ClientDownloadRequest_Resource::set_referrer(const char* value) {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  referrer_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.Resource.referrer)
+}
+inline void ClientDownloadRequest_Resource::set_referrer(const char* value, size_t size) {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  referrer_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.Resource.referrer)
+}
+inline ::std::string* ClientDownloadRequest_Resource::mutable_referrer() {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.Resource.referrer)
+  return referrer_;
+}
+inline ::std::string* ClientDownloadRequest_Resource::release_referrer() {
+  clear_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = referrer_;
+    referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_Resource::set_allocated_referrer(::std::string* referrer) {
+  if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete referrer_;
+  }
+  if (referrer) {
+    set_has_referrer();
+    referrer_ = referrer;
+  } else {
+    clear_has_referrer();
+    referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.Resource.referrer)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_CertificateChain_Element
+
+// optional bytes certificate = 1;
+inline bool ClientDownloadRequest_CertificateChain_Element::has_certificate() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadRequest_CertificateChain_Element::set_has_certificate() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadRequest_CertificateChain_Element::clear_has_certificate() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadRequest_CertificateChain_Element::clear_certificate() {
+  if (certificate_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    certificate_->clear();
+  }
+  clear_has_certificate();
+}
+inline const ::std::string& ClientDownloadRequest_CertificateChain_Element::certificate() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate)
+  return *certificate_;
+}
+inline void ClientDownloadRequest_CertificateChain_Element::set_certificate(const ::std::string& value) {
+  set_has_certificate();
+  if (certificate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    certificate_ = new ::std::string;
+  }
+  certificate_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate)
+}
+inline void ClientDownloadRequest_CertificateChain_Element::set_certificate(const char* value) {
+  set_has_certificate();
+  if (certificate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    certificate_ = new ::std::string;
+  }
+  certificate_->assign(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) {
+  set_has_certificate();
+  if (certificate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    certificate_ = new ::std::string;
+  }
+  certificate_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate)
+}
+inline ::std::string* ClientDownloadRequest_CertificateChain_Element::mutable_certificate() {
+  set_has_certificate();
+  if (certificate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    certificate_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.CertificateChain.Element.certificate)
+  return certificate_;
+}
+inline ::std::string* ClientDownloadRequest_CertificateChain_Element::release_certificate() {
+  clear_has_certificate();
+  if (certificate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = certificate_;
+    certificate_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_CertificateChain_Element::set_allocated_certificate(::std::string* certificate) {
+  if (certificate_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete certificate_;
+  }
+  if (certificate) {
+    set_has_certificate();
+    certificate_ = certificate;
+  } else {
+    clear_has_certificate();
+    certificate_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::element_size() const {
+  return element_.size();
+}
+inline void ClientDownloadRequest_CertificateChain::clear_element() {
+  element_.Clear();
+}
+inline const ::safe_browsing::ClientDownloadRequest_CertificateChain_Element& ClientDownloadRequest_CertificateChain::element(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.CertificateChain.element)
+  return element_.Get(index);
+}
+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 ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* ClientDownloadRequest_CertificateChain::add_element() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.CertificateChain.element)
+  return element_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >&
+ClientDownloadRequest_CertificateChain::element() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.CertificateChain.element)
+  return element_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >*
+ClientDownloadRequest_CertificateChain::mutable_element() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.CertificateChain.element)
+  return &element_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_ExtendedAttr
+
+// required string key = 1;
+inline bool ClientDownloadRequest_ExtendedAttr::has_key() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadRequest_ExtendedAttr::set_has_key() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadRequest_ExtendedAttr::clear_has_key() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadRequest_ExtendedAttr::clear_key() {
+  if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    key_->clear();
+  }
+  clear_has_key();
+}
+inline const ::std::string& ClientDownloadRequest_ExtendedAttr::key() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ExtendedAttr.key)
+  return *key_;
+}
+inline void ClientDownloadRequest_ExtendedAttr::set_key(const ::std::string& value) {
+  set_has_key();
+  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    key_ = new ::std::string;
+  }
+  key_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.ExtendedAttr.key)
+}
+inline void ClientDownloadRequest_ExtendedAttr::set_key(const char* value) {
+  set_has_key();
+  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    key_ = new ::std::string;
+  }
+  key_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.ExtendedAttr.key)
+}
+inline void ClientDownloadRequest_ExtendedAttr::set_key(const char* value, size_t size) {
+  set_has_key();
+  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    key_ = new ::std::string;
+  }
+  key_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.ExtendedAttr.key)
+}
+inline ::std::string* ClientDownloadRequest_ExtendedAttr::mutable_key() {
+  set_has_key();
+  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    key_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ExtendedAttr.key)
+  return key_;
+}
+inline ::std::string* ClientDownloadRequest_ExtendedAttr::release_key() {
+  clear_has_key();
+  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = key_;
+    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_ExtendedAttr::set_allocated_key(::std::string* key) {
+  if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete key_;
+  }
+  if (key) {
+    set_has_key();
+    key_ = key;
+  } else {
+    clear_has_key();
+    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.ExtendedAttr.key)
+}
+
+// optional bytes value = 2;
+inline bool ClientDownloadRequest_ExtendedAttr::has_value() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientDownloadRequest_ExtendedAttr::set_has_value() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientDownloadRequest_ExtendedAttr::clear_has_value() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientDownloadRequest_ExtendedAttr::clear_value() {
+  if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_->clear();
+  }
+  clear_has_value();
+}
+inline const ::std::string& ClientDownloadRequest_ExtendedAttr::value() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ExtendedAttr.value)
+  return *value_;
+}
+inline void ClientDownloadRequest_ExtendedAttr::set_value(const ::std::string& value) {
+  set_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_ = new ::std::string;
+  }
+  value_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.ExtendedAttr.value)
+}
+inline void ClientDownloadRequest_ExtendedAttr::set_value(const char* value) {
+  set_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_ = new ::std::string;
+  }
+  value_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.ExtendedAttr.value)
+}
+inline void ClientDownloadRequest_ExtendedAttr::set_value(const void* value, size_t size) {
+  set_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_ = new ::std::string;
+  }
+  value_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.ExtendedAttr.value)
+}
+inline ::std::string* ClientDownloadRequest_ExtendedAttr::mutable_value() {
+  set_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ExtendedAttr.value)
+  return value_;
+}
+inline ::std::string* ClientDownloadRequest_ExtendedAttr::release_value() {
+  clear_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = value_;
+    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_ExtendedAttr::set_allocated_value(::std::string* value) {
+  if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete value_;
+  }
+  if (value) {
+    set_has_value();
+    value_ = value;
+  } else {
+    clear_has_value();
+    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.ExtendedAttr.value)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_SignatureInfo
+
+// repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1;
+inline int ClientDownloadRequest_SignatureInfo::certificate_chain_size() const {
+  return certificate_chain_.size();
+}
+inline void ClientDownloadRequest_SignatureInfo::clear_certificate_chain() {
+  certificate_chain_.Clear();
+}
+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 certificate_chain_.Get(index);
+}
+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 ::safe_browsing::ClientDownloadRequest_CertificateChain* ClientDownloadRequest_SignatureInfo::add_certificate_chain() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.SignatureInfo.certificate_chain)
+  return certificate_chain_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain >&
+ClientDownloadRequest_SignatureInfo::certificate_chain() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.SignatureInfo.certificate_chain)
+  return certificate_chain_;
+}
+inline ::google::protobuf::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_;
+}
+
+// optional bool trusted = 2;
+inline bool ClientDownloadRequest_SignatureInfo::has_trusted() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientDownloadRequest_SignatureInfo::set_has_trusted() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientDownloadRequest_SignatureInfo::clear_has_trusted() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientDownloadRequest_SignatureInfo::clear_trusted() {
+  trusted_ = false;
+  clear_has_trusted();
+}
+inline bool ClientDownloadRequest_SignatureInfo::trusted() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.SignatureInfo.trusted)
+  return trusted_;
+}
+inline void ClientDownloadRequest_SignatureInfo::set_trusted(bool value) {
+  set_has_trusted();
+  trusted_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.SignatureInfo.trusted)
+}
+
+// repeated bytes signed_data = 3;
+inline int ClientDownloadRequest_SignatureInfo::signed_data_size() const {
+  return signed_data_.size();
+}
+inline void ClientDownloadRequest_SignatureInfo::clear_signed_data() {
+  signed_data_.Clear();
+}
+inline const ::std::string& ClientDownloadRequest_SignatureInfo::signed_data(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+  return signed_data_.Get(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, const char* value) {
+  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::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(const char* value) {
+  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 ::google::protobuf::RepeatedPtrField< ::std::string>&
+ClientDownloadRequest_SignatureInfo::signed_data() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.SignatureInfo.signed_data)
+  return signed_data_;
+}
+inline ::google::protobuf::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::xattr_size() const {
+  return xattr_.size();
+}
+inline void ClientDownloadRequest_SignatureInfo::clear_xattr() {
+  xattr_.Clear();
+}
+inline const ::safe_browsing::ClientDownloadRequest_ExtendedAttr& ClientDownloadRequest_SignatureInfo::xattr(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.SignatureInfo.xattr)
+  return xattr_.Get(index);
+}
+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 ::safe_browsing::ClientDownloadRequest_ExtendedAttr* ClientDownloadRequest_SignatureInfo::add_xattr() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.SignatureInfo.xattr)
+  return xattr_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ExtendedAttr >&
+ClientDownloadRequest_SignatureInfo::xattr() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.SignatureInfo.xattr)
+  return xattr_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ExtendedAttr >*
+ClientDownloadRequest_SignatureInfo::mutable_xattr() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.SignatureInfo.xattr)
+  return &xattr_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_PEImageHeaders_DebugData
+
+// optional bytes directory_entry = 1;
+inline bool ClientDownloadRequest_PEImageHeaders_DebugData::has_directory_entry() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_has_directory_entry() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::clear_has_directory_entry() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::clear_directory_entry() {
+  if (directory_entry_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    directory_entry_->clear();
+  }
+  clear_has_directory_entry();
+}
+inline const ::std::string& ClientDownloadRequest_PEImageHeaders_DebugData::directory_entry() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry)
+  return *directory_entry_;
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_directory_entry(const ::std::string& value) {
+  set_has_directory_entry();
+  if (directory_entry_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    directory_entry_ = new ::std::string;
+  }
+  directory_entry_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry)
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_directory_entry(const char* value) {
+  set_has_directory_entry();
+  if (directory_entry_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    directory_entry_ = new ::std::string;
+  }
+  directory_entry_->assign(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) {
+  set_has_directory_entry();
+  if (directory_entry_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    directory_entry_ = new ::std::string;
+  }
+  directory_entry_->assign(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::mutable_directory_entry() {
+  set_has_directory_entry();
+  if (directory_entry_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    directory_entry_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry)
+  return directory_entry_;
+}
+inline ::std::string* ClientDownloadRequest_PEImageHeaders_DebugData::release_directory_entry() {
+  clear_has_directory_entry();
+  if (directory_entry_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = directory_entry_;
+    directory_entry_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_allocated_directory_entry(::std::string* directory_entry) {
+  if (directory_entry_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete directory_entry_;
+  }
+  if (directory_entry) {
+    set_has_directory_entry();
+    directory_entry_ = directory_entry;
+  } else {
+    clear_has_directory_entry();
+    directory_entry_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.directory_entry)
+}
+
+// optional bytes raw_data = 2;
+inline bool ClientDownloadRequest_PEImageHeaders_DebugData::has_raw_data() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_has_raw_data() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::clear_has_raw_data() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::clear_raw_data() {
+  if (raw_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raw_data_->clear();
+  }
+  clear_has_raw_data();
+}
+inline const ::std::string& ClientDownloadRequest_PEImageHeaders_DebugData::raw_data() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data)
+  return *raw_data_;
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_raw_data(const ::std::string& value) {
+  set_has_raw_data();
+  if (raw_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raw_data_ = new ::std::string;
+  }
+  raw_data_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data)
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_raw_data(const char* value) {
+  set_has_raw_data();
+  if (raw_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raw_data_ = new ::std::string;
+  }
+  raw_data_->assign(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) {
+  set_has_raw_data();
+  if (raw_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raw_data_ = new ::std::string;
+  }
+  raw_data_->assign(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::mutable_raw_data() {
+  set_has_raw_data();
+  if (raw_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raw_data_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data)
+  return raw_data_;
+}
+inline ::std::string* ClientDownloadRequest_PEImageHeaders_DebugData::release_raw_data() {
+  clear_has_raw_data();
+  if (raw_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = raw_data_;
+    raw_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_PEImageHeaders_DebugData::set_allocated_raw_data(::std::string* raw_data) {
+  if (raw_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete raw_data_;
+  }
+  if (raw_data) {
+    set_has_raw_data();
+    raw_data_ = raw_data;
+  } else {
+    clear_has_raw_data();
+    raw_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.PEImageHeaders.DebugData.raw_data)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_PEImageHeaders
+
+// optional bytes dos_header = 1;
+inline bool ClientDownloadRequest_PEImageHeaders::has_dos_header() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_has_dos_header() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_has_dos_header() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_dos_header() {
+  if (dos_header_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    dos_header_->clear();
+  }
+  clear_has_dos_header();
+}
+inline const ::std::string& ClientDownloadRequest_PEImageHeaders::dos_header() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header)
+  return *dos_header_;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_dos_header(const ::std::string& value) {
+  set_has_dos_header();
+  if (dos_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    dos_header_ = new ::std::string;
+  }
+  dos_header_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header)
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_dos_header(const char* value) {
+  set_has_dos_header();
+  if (dos_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    dos_header_ = new ::std::string;
+  }
+  dos_header_->assign(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) {
+  set_has_dos_header();
+  if (dos_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    dos_header_ = new ::std::string;
+  }
+  dos_header_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header)
+}
+inline ::std::string* ClientDownloadRequest_PEImageHeaders::mutable_dos_header() {
+  set_has_dos_header();
+  if (dos_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    dos_header_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header)
+  return dos_header_;
+}
+inline ::std::string* ClientDownloadRequest_PEImageHeaders::release_dos_header() {
+  clear_has_dos_header();
+  if (dos_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = dos_header_;
+    dos_header_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_allocated_dos_header(::std::string* dos_header) {
+  if (dos_header_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete dos_header_;
+  }
+  if (dos_header) {
+    set_has_dos_header();
+    dos_header_ = dos_header;
+  } else {
+    clear_has_dos_header();
+    dos_header_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.PEImageHeaders.dos_header)
+}
+
+// optional bytes file_header = 2;
+inline bool ClientDownloadRequest_PEImageHeaders::has_file_header() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_has_file_header() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_has_file_header() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_file_header() {
+  if (file_header_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_header_->clear();
+  }
+  clear_has_file_header();
+}
+inline const ::std::string& ClientDownloadRequest_PEImageHeaders::file_header() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header)
+  return *file_header_;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_file_header(const ::std::string& value) {
+  set_has_file_header();
+  if (file_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_header_ = new ::std::string;
+  }
+  file_header_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header)
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_file_header(const char* value) {
+  set_has_file_header();
+  if (file_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_header_ = new ::std::string;
+  }
+  file_header_->assign(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) {
+  set_has_file_header();
+  if (file_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_header_ = new ::std::string;
+  }
+  file_header_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header)
+}
+inline ::std::string* ClientDownloadRequest_PEImageHeaders::mutable_file_header() {
+  set_has_file_header();
+  if (file_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_header_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header)
+  return file_header_;
+}
+inline ::std::string* ClientDownloadRequest_PEImageHeaders::release_file_header() {
+  clear_has_file_header();
+  if (file_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = file_header_;
+    file_header_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_allocated_file_header(::std::string* file_header) {
+  if (file_header_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete file_header_;
+  }
+  if (file_header) {
+    set_has_file_header();
+    file_header_ = file_header;
+  } else {
+    clear_has_file_header();
+    file_header_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.PEImageHeaders.file_header)
+}
+
+// optional bytes optional_headers32 = 3;
+inline bool ClientDownloadRequest_PEImageHeaders::has_optional_headers32() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_has_optional_headers32() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_has_optional_headers32() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_optional_headers32() {
+  if (optional_headers32_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    optional_headers32_->clear();
+  }
+  clear_has_optional_headers32();
+}
+inline const ::std::string& ClientDownloadRequest_PEImageHeaders::optional_headers32() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32)
+  return *optional_headers32_;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_optional_headers32(const ::std::string& value) {
+  set_has_optional_headers32();
+  if (optional_headers32_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    optional_headers32_ = new ::std::string;
+  }
+  optional_headers32_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32)
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_optional_headers32(const char* value) {
+  set_has_optional_headers32();
+  if (optional_headers32_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    optional_headers32_ = new ::std::string;
+  }
+  optional_headers32_->assign(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) {
+  set_has_optional_headers32();
+  if (optional_headers32_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    optional_headers32_ = new ::std::string;
+  }
+  optional_headers32_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32)
+}
+inline ::std::string* ClientDownloadRequest_PEImageHeaders::mutable_optional_headers32() {
+  set_has_optional_headers32();
+  if (optional_headers32_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    optional_headers32_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32)
+  return optional_headers32_;
+}
+inline ::std::string* ClientDownloadRequest_PEImageHeaders::release_optional_headers32() {
+  clear_has_optional_headers32();
+  if (optional_headers32_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = optional_headers32_;
+    optional_headers32_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_allocated_optional_headers32(::std::string* optional_headers32) {
+  if (optional_headers32_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete optional_headers32_;
+  }
+  if (optional_headers32) {
+    set_has_optional_headers32();
+    optional_headers32_ = optional_headers32;
+  } else {
+    clear_has_optional_headers32();
+    optional_headers32_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers32)
+}
+
+// optional bytes optional_headers64 = 4;
+inline bool ClientDownloadRequest_PEImageHeaders::has_optional_headers64() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_has_optional_headers64() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_has_optional_headers64() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_optional_headers64() {
+  if (optional_headers64_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    optional_headers64_->clear();
+  }
+  clear_has_optional_headers64();
+}
+inline const ::std::string& ClientDownloadRequest_PEImageHeaders::optional_headers64() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64)
+  return *optional_headers64_;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_optional_headers64(const ::std::string& value) {
+  set_has_optional_headers64();
+  if (optional_headers64_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    optional_headers64_ = new ::std::string;
+  }
+  optional_headers64_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64)
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_optional_headers64(const char* value) {
+  set_has_optional_headers64();
+  if (optional_headers64_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    optional_headers64_ = new ::std::string;
+  }
+  optional_headers64_->assign(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) {
+  set_has_optional_headers64();
+  if (optional_headers64_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    optional_headers64_ = new ::std::string;
+  }
+  optional_headers64_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64)
+}
+inline ::std::string* ClientDownloadRequest_PEImageHeaders::mutable_optional_headers64() {
+  set_has_optional_headers64();
+  if (optional_headers64_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    optional_headers64_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64)
+  return optional_headers64_;
+}
+inline ::std::string* ClientDownloadRequest_PEImageHeaders::release_optional_headers64() {
+  clear_has_optional_headers64();
+  if (optional_headers64_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = optional_headers64_;
+    optional_headers64_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_allocated_optional_headers64(::std::string* optional_headers64) {
+  if (optional_headers64_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete optional_headers64_;
+  }
+  if (optional_headers64) {
+    set_has_optional_headers64();
+    optional_headers64_ = optional_headers64;
+  } else {
+    clear_has_optional_headers64();
+    optional_headers64_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.PEImageHeaders.optional_headers64)
+}
+
+// repeated bytes section_header = 5;
+inline int ClientDownloadRequest_PEImageHeaders::section_header_size() const {
+  return section_header_.size();
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_section_header() {
+  section_header_.Clear();
+}
+inline const ::std::string& ClientDownloadRequest_PEImageHeaders::section_header(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+  return section_header_.Get(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, const char* value) {
+  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::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(const char* value) {
+  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 ::google::protobuf::RepeatedPtrField< ::std::string>&
+ClientDownloadRequest_PEImageHeaders::section_header() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+  return section_header_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+ClientDownloadRequest_PEImageHeaders::mutable_section_header() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.PEImageHeaders.section_header)
+  return &section_header_;
+}
+
+// optional bytes export_section_data = 6;
+inline bool ClientDownloadRequest_PEImageHeaders::has_export_section_data() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_has_export_section_data() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_has_export_section_data() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_export_section_data() {
+  if (export_section_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    export_section_data_->clear();
+  }
+  clear_has_export_section_data();
+}
+inline const ::std::string& ClientDownloadRequest_PEImageHeaders::export_section_data() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data)
+  return *export_section_data_;
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_export_section_data(const ::std::string& value) {
+  set_has_export_section_data();
+  if (export_section_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    export_section_data_ = new ::std::string;
+  }
+  export_section_data_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data)
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_export_section_data(const char* value) {
+  set_has_export_section_data();
+  if (export_section_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    export_section_data_ = new ::std::string;
+  }
+  export_section_data_->assign(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) {
+  set_has_export_section_data();
+  if (export_section_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    export_section_data_ = new ::std::string;
+  }
+  export_section_data_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data)
+}
+inline ::std::string* ClientDownloadRequest_PEImageHeaders::mutable_export_section_data() {
+  set_has_export_section_data();
+  if (export_section_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    export_section_data_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.PEImageHeaders.export_section_data)
+  return export_section_data_;
+}
+inline ::std::string* ClientDownloadRequest_PEImageHeaders::release_export_section_data() {
+  clear_has_export_section_data();
+  if (export_section_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = export_section_data_;
+    export_section_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_PEImageHeaders::set_allocated_export_section_data(::std::string* export_section_data) {
+  if (export_section_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete export_section_data_;
+  }
+  if (export_section_data) {
+    set_has_export_section_data();
+    export_section_data_ = export_section_data;
+  } else {
+    clear_has_export_section_data();
+    export_section_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::debug_data_size() const {
+  return debug_data_.size();
+}
+inline void ClientDownloadRequest_PEImageHeaders::clear_debug_data() {
+  debug_data_.Clear();
+}
+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 debug_data_.Get(index);
+}
+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 ::safe_browsing::ClientDownloadRequest_PEImageHeaders_DebugData* ClientDownloadRequest_PEImageHeaders::add_debug_data() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.PEImageHeaders.debug_data)
+  return debug_data_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_MachOHeaders_LoadCommand
+
+// required uint32 command_id = 1;
+inline bool ClientDownloadRequest_MachOHeaders_LoadCommand::has_command_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_has_command_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::clear_has_command_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::clear_command_id() {
+  command_id_ = 0u;
+  clear_has_command_id();
+}
+inline ::google::protobuf::uint32 ClientDownloadRequest_MachOHeaders_LoadCommand::command_id() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command_id)
+  return command_id_;
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_command_id(::google::protobuf::uint32 value) {
+  set_has_command_id();
+  command_id_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command_id)
+}
+
+// required bytes command = 2;
+inline bool ClientDownloadRequest_MachOHeaders_LoadCommand::has_command() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_has_command() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::clear_has_command() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::clear_command() {
+  if (command_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    command_->clear();
+  }
+  clear_has_command();
+}
+inline const ::std::string& ClientDownloadRequest_MachOHeaders_LoadCommand::command() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command)
+  return *command_;
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_command(const ::std::string& value) {
+  set_has_command();
+  if (command_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    command_ = new ::std::string;
+  }
+  command_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command)
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_command(const char* value) {
+  set_has_command();
+  if (command_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    command_ = new ::std::string;
+  }
+  command_->assign(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) {
+  set_has_command();
+  if (command_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    command_ = new ::std::string;
+  }
+  command_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command)
+}
+inline ::std::string* ClientDownloadRequest_MachOHeaders_LoadCommand::mutable_command() {
+  set_has_command();
+  if (command_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    command_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command)
+  return command_;
+}
+inline ::std::string* ClientDownloadRequest_MachOHeaders_LoadCommand::release_command() {
+  clear_has_command();
+  if (command_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = command_;
+    command_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_MachOHeaders_LoadCommand::set_allocated_command(::std::string* command) {
+  if (command_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete command_;
+  }
+  if (command) {
+    set_has_command();
+    command_ = command;
+  } else {
+    clear_has_command();
+    command_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.MachOHeaders.LoadCommand.command)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_MachOHeaders
+
+// required bytes mach_header = 1;
+inline bool ClientDownloadRequest_MachOHeaders::has_mach_header() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadRequest_MachOHeaders::set_has_mach_header() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadRequest_MachOHeaders::clear_has_mach_header() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadRequest_MachOHeaders::clear_mach_header() {
+  if (mach_header_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    mach_header_->clear();
+  }
+  clear_has_mach_header();
+}
+inline const ::std::string& ClientDownloadRequest_MachOHeaders::mach_header() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header)
+  return *mach_header_;
+}
+inline void ClientDownloadRequest_MachOHeaders::set_mach_header(const ::std::string& value) {
+  set_has_mach_header();
+  if (mach_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    mach_header_ = new ::std::string;
+  }
+  mach_header_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header)
+}
+inline void ClientDownloadRequest_MachOHeaders::set_mach_header(const char* value) {
+  set_has_mach_header();
+  if (mach_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    mach_header_ = new ::std::string;
+  }
+  mach_header_->assign(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) {
+  set_has_mach_header();
+  if (mach_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    mach_header_ = new ::std::string;
+  }
+  mach_header_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header)
+}
+inline ::std::string* ClientDownloadRequest_MachOHeaders::mutable_mach_header() {
+  set_has_mach_header();
+  if (mach_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    mach_header_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.MachOHeaders.mach_header)
+  return mach_header_;
+}
+inline ::std::string* ClientDownloadRequest_MachOHeaders::release_mach_header() {
+  clear_has_mach_header();
+  if (mach_header_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = mach_header_;
+    mach_header_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_MachOHeaders::set_allocated_mach_header(::std::string* mach_header) {
+  if (mach_header_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete mach_header_;
+  }
+  if (mach_header) {
+    set_has_mach_header();
+    mach_header_ = mach_header;
+  } else {
+    clear_has_mach_header();
+    mach_header_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::load_commands_size() const {
+  return load_commands_.size();
+}
+inline void ClientDownloadRequest_MachOHeaders::clear_load_commands() {
+  load_commands_.Clear();
+}
+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 load_commands_.Get(index);
+}
+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 ::safe_browsing::ClientDownloadRequest_MachOHeaders_LoadCommand* ClientDownloadRequest_MachOHeaders::add_load_commands() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.MachOHeaders.load_commands)
+  return load_commands_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_ImageHeaders
+
+// optional .safe_browsing.ClientDownloadRequest.PEImageHeaders pe_headers = 1;
+inline bool ClientDownloadRequest_ImageHeaders::has_pe_headers() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadRequest_ImageHeaders::set_has_pe_headers() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadRequest_ImageHeaders::clear_has_pe_headers() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadRequest_ImageHeaders::clear_pe_headers() {
+  if (pe_headers_ != NULL) pe_headers_->::safe_browsing::ClientDownloadRequest_PEImageHeaders::Clear();
+  clear_has_pe_headers();
+}
+inline const ::safe_browsing::ClientDownloadRequest_PEImageHeaders& ClientDownloadRequest_ImageHeaders::pe_headers() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ImageHeaders.pe_headers)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return pe_headers_ != NULL ? *pe_headers_ : *default_instance().pe_headers_;
+#else
+  return pe_headers_ != NULL ? *pe_headers_ : *default_instance_->pe_headers_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders* ClientDownloadRequest_ImageHeaders::mutable_pe_headers() {
+  set_has_pe_headers();
+  if (pe_headers_ == NULL) pe_headers_ = new ::safe_browsing::ClientDownloadRequest_PEImageHeaders;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ImageHeaders.pe_headers)
+  return pe_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_PEImageHeaders* ClientDownloadRequest_ImageHeaders::release_pe_headers() {
+  clear_has_pe_headers();
+  ::safe_browsing::ClientDownloadRequest_PEImageHeaders* temp = pe_headers_;
+  pe_headers_ = NULL;
+  return temp;
+}
+inline void ClientDownloadRequest_ImageHeaders::set_allocated_pe_headers(::safe_browsing::ClientDownloadRequest_PEImageHeaders* pe_headers) {
+  delete pe_headers_;
+  pe_headers_ = pe_headers;
+  if (pe_headers) {
+    set_has_pe_headers();
+  } else {
+    clear_has_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::mach_o_headers_size() const {
+  return mach_o_headers_.size();
+}
+inline void ClientDownloadRequest_ImageHeaders::clear_mach_o_headers() {
+  mach_o_headers_.Clear();
+}
+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 mach_o_headers_.Get(index);
+}
+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 ::safe_browsing::ClientDownloadRequest_MachOHeaders* ClientDownloadRequest_ImageHeaders::add_mach_o_headers() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.ImageHeaders.mach_o_headers)
+  return mach_o_headers_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_ArchivedBinary
+
+// optional string file_basename = 1;
+inline bool ClientDownloadRequest_ArchivedBinary::has_file_basename() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_has_file_basename() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_has_file_basename() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_file_basename() {
+  if (file_basename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_->clear();
+  }
+  clear_has_file_basename();
+}
+inline const ::std::string& ClientDownloadRequest_ArchivedBinary::file_basename() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename)
+  return *file_basename_;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_file_basename(const ::std::string& value) {
+  set_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_ = new ::std::string;
+  }
+  file_basename_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename)
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_file_basename(const char* value) {
+  set_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_ = new ::std::string;
+  }
+  file_basename_->assign(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) {
+  set_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_ = new ::std::string;
+  }
+  file_basename_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename)
+}
+inline ::std::string* ClientDownloadRequest_ArchivedBinary::mutable_file_basename() {
+  set_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename)
+  return file_basename_;
+}
+inline ::std::string* ClientDownloadRequest_ArchivedBinary::release_file_basename() {
+  clear_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = file_basename_;
+    file_basename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_allocated_file_basename(::std::string* file_basename) {
+  if (file_basename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete file_basename_;
+  }
+  if (file_basename) {
+    set_has_file_basename();
+    file_basename_ = file_basename;
+  } else {
+    clear_has_file_basename();
+    file_basename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.ArchivedBinary.file_basename)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 2;
+inline bool ClientDownloadRequest_ArchivedBinary::has_download_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_has_download_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_has_download_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_download_type() {
+  download_type_ = 0;
+  clear_has_download_type();
+}
+inline ::safe_browsing::ClientDownloadRequest_DownloadType ClientDownloadRequest_ArchivedBinary::download_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ArchivedBinary.download_type)
+  return static_cast< ::safe_browsing::ClientDownloadRequest_DownloadType >(download_type_);
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value) {
+  assert(::safe_browsing::ClientDownloadRequest_DownloadType_IsValid(value));
+  set_has_download_type();
+  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::has_digests() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_has_digests() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_has_digests() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_digests() {
+  if (digests_ != NULL) digests_->::safe_browsing::ClientDownloadRequest_Digests::Clear();
+  clear_has_digests();
+}
+inline const ::safe_browsing::ClientDownloadRequest_Digests& ClientDownloadRequest_ArchivedBinary::digests() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ArchivedBinary.digests)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return digests_ != NULL ? *digests_ : *default_instance().digests_;
+#else
+  return digests_ != NULL ? *digests_ : *default_instance_->digests_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest_ArchivedBinary::mutable_digests() {
+  set_has_digests();
+  if (digests_ == NULL) digests_ = new ::safe_browsing::ClientDownloadRequest_Digests;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ArchivedBinary.digests)
+  return digests_;
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest_ArchivedBinary::release_digests() {
+  clear_has_digests();
+  ::safe_browsing::ClientDownloadRequest_Digests* temp = digests_;
+  digests_ = NULL;
+  return temp;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_allocated_digests(::safe_browsing::ClientDownloadRequest_Digests* digests) {
+  delete digests_;
+  digests_ = digests;
+  if (digests) {
+    set_has_digests();
+  } else {
+    clear_has_digests();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.ArchivedBinary.digests)
+}
+
+// optional int64 length = 4;
+inline bool ClientDownloadRequest_ArchivedBinary::has_length() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_has_length() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_has_length() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_length() {
+  length_ = GOOGLE_LONGLONG(0);
+  clear_has_length();
+}
+inline ::google::protobuf::int64 ClientDownloadRequest_ArchivedBinary::length() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ArchivedBinary.length)
+  return length_;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_length(::google::protobuf::int64 value) {
+  set_has_length();
+  length_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.ArchivedBinary.length)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+inline bool ClientDownloadRequest_ArchivedBinary::has_signature() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_has_signature() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_has_signature() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_signature() {
+  if (signature_ != NULL) signature_->::safe_browsing::ClientDownloadRequest_SignatureInfo::Clear();
+  clear_has_signature();
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientDownloadRequest_ArchivedBinary::signature() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ArchivedBinary.signature)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return signature_ != NULL ? *signature_ : *default_instance().signature_;
+#else
+  return signature_ != NULL ? *signature_ : *default_instance_->signature_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest_ArchivedBinary::mutable_signature() {
+  set_has_signature();
+  if (signature_ == NULL) signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ArchivedBinary.signature)
+  return signature_;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest_ArchivedBinary::release_signature() {
+  clear_has_signature();
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = signature_;
+  signature_ = NULL;
+  return temp;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  delete signature_;
+  signature_ = signature;
+  if (signature) {
+    set_has_signature();
+  } else {
+    clear_has_signature();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.ArchivedBinary.signature)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+inline bool ClientDownloadRequest_ArchivedBinary::has_image_headers() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_has_image_headers() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_has_image_headers() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClientDownloadRequest_ArchivedBinary::clear_image_headers() {
+  if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+  clear_has_image_headers();
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientDownloadRequest_ArchivedBinary::image_headers() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.ArchivedBinary.image_headers)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return image_headers_ != NULL ? *image_headers_ : *default_instance().image_headers_;
+#else
+  return image_headers_ != NULL ? *image_headers_ : *default_instance_->image_headers_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest_ArchivedBinary::mutable_image_headers() {
+  set_has_image_headers();
+  if (image_headers_ == NULL) image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.ArchivedBinary.image_headers)
+  return image_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest_ArchivedBinary::release_image_headers() {
+  clear_has_image_headers();
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = image_headers_;
+  image_headers_ = NULL;
+  return temp;
+}
+inline void ClientDownloadRequest_ArchivedBinary::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  delete image_headers_;
+  image_headers_ = image_headers;
+  if (image_headers) {
+    set_has_image_headers();
+  } else {
+    clear_has_image_headers();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.ArchivedBinary.image_headers)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest_URLChainEntry
+
+// optional string url = 1;
+inline bool ClientDownloadRequest_URLChainEntry::has_url() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_has_url() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_has_url() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_url() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_->clear();
+  }
+  clear_has_url();
+}
+inline const ::std::string& ClientDownloadRequest_URLChainEntry::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.URLChainEntry.url)
+  return *url_;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_url(const ::std::string& value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.URLChainEntry.url)
+}
+inline void ClientDownloadRequest_URLChainEntry::set_url(const char* value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.URLChainEntry.url)
+}
+inline void ClientDownloadRequest_URLChainEntry::set_url(const char* value, size_t size) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.URLChainEntry.url)
+}
+inline ::std::string* ClientDownloadRequest_URLChainEntry::mutable_url() {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.URLChainEntry.url)
+  return url_;
+}
+inline ::std::string* ClientDownloadRequest_URLChainEntry::release_url() {
+  clear_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_;
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_URLChainEntry::set_allocated_url(::std::string* url) {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (url) {
+    set_has_url();
+    url_ = url;
+  } else {
+    clear_has_url();
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.URLChainEntry.url)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.URLChainEntry.URLType type = 2;
+inline bool ClientDownloadRequest_URLChainEntry::has_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_has_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_has_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_type() {
+  type_ = 1;
+  clear_has_type();
+}
+inline ::safe_browsing::ClientDownloadRequest_URLChainEntry_URLType ClientDownloadRequest_URLChainEntry::type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.URLChainEntry.type)
+  return static_cast< ::safe_browsing::ClientDownloadRequest_URLChainEntry_URLType >(type_);
+}
+inline void ClientDownloadRequest_URLChainEntry::set_type(::safe_browsing::ClientDownloadRequest_URLChainEntry_URLType value) {
+  assert(::safe_browsing::ClientDownloadRequest_URLChainEntry_URLType_IsValid(value));
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.URLChainEntry.type)
+}
+
+// optional string ip_address = 3;
+inline bool ClientDownloadRequest_URLChainEntry::has_ip_address() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_has_ip_address() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_has_ip_address() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_ip_address() {
+  if (ip_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_address_->clear();
+  }
+  clear_has_ip_address();
+}
+inline const ::std::string& ClientDownloadRequest_URLChainEntry::ip_address() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.URLChainEntry.ip_address)
+  return *ip_address_;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_ip_address(const ::std::string& value) {
+  set_has_ip_address();
+  if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_address_ = new ::std::string;
+  }
+  ip_address_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.URLChainEntry.ip_address)
+}
+inline void ClientDownloadRequest_URLChainEntry::set_ip_address(const char* value) {
+  set_has_ip_address();
+  if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_address_ = new ::std::string;
+  }
+  ip_address_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.URLChainEntry.ip_address)
+}
+inline void ClientDownloadRequest_URLChainEntry::set_ip_address(const char* value, size_t size) {
+  set_has_ip_address();
+  if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_address_ = new ::std::string;
+  }
+  ip_address_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.URLChainEntry.ip_address)
+}
+inline ::std::string* ClientDownloadRequest_URLChainEntry::mutable_ip_address() {
+  set_has_ip_address();
+  if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_address_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.URLChainEntry.ip_address)
+  return ip_address_;
+}
+inline ::std::string* ClientDownloadRequest_URLChainEntry::release_ip_address() {
+  clear_has_ip_address();
+  if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = ip_address_;
+    ip_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_URLChainEntry::set_allocated_ip_address(::std::string* ip_address) {
+  if (ip_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete ip_address_;
+  }
+  if (ip_address) {
+    set_has_ip_address();
+    ip_address_ = ip_address;
+  } else {
+    clear_has_ip_address();
+    ip_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.URLChainEntry.ip_address)
+}
+
+// optional string referrer = 4;
+inline bool ClientDownloadRequest_URLChainEntry::has_referrer() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_has_referrer() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_has_referrer() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_referrer() {
+  if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_->clear();
+  }
+  clear_has_referrer();
+}
+inline const ::std::string& ClientDownloadRequest_URLChainEntry::referrer() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.URLChainEntry.referrer)
+  return *referrer_;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_referrer(const ::std::string& value) {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  referrer_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.URLChainEntry.referrer)
+}
+inline void ClientDownloadRequest_URLChainEntry::set_referrer(const char* value) {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  referrer_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.URLChainEntry.referrer)
+}
+inline void ClientDownloadRequest_URLChainEntry::set_referrer(const char* value, size_t size) {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  referrer_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.URLChainEntry.referrer)
+}
+inline ::std::string* ClientDownloadRequest_URLChainEntry::mutable_referrer() {
+  set_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.URLChainEntry.referrer)
+  return referrer_;
+}
+inline ::std::string* ClientDownloadRequest_URLChainEntry::release_referrer() {
+  clear_has_referrer();
+  if (referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = referrer_;
+    referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_URLChainEntry::set_allocated_referrer(::std::string* referrer) {
+  if (referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete referrer_;
+  }
+  if (referrer) {
+    set_has_referrer();
+    referrer_ = referrer;
+  } else {
+    clear_has_referrer();
+    referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.URLChainEntry.referrer)
+}
+
+// optional string main_frame_referrer = 5;
+inline bool ClientDownloadRequest_URLChainEntry::has_main_frame_referrer() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_has_main_frame_referrer() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_has_main_frame_referrer() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_main_frame_referrer() {
+  if (main_frame_referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    main_frame_referrer_->clear();
+  }
+  clear_has_main_frame_referrer();
+}
+inline const ::std::string& ClientDownloadRequest_URLChainEntry::main_frame_referrer() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.URLChainEntry.main_frame_referrer)
+  return *main_frame_referrer_;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_main_frame_referrer(const ::std::string& value) {
+  set_has_main_frame_referrer();
+  if (main_frame_referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    main_frame_referrer_ = new ::std::string;
+  }
+  main_frame_referrer_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.URLChainEntry.main_frame_referrer)
+}
+inline void ClientDownloadRequest_URLChainEntry::set_main_frame_referrer(const char* value) {
+  set_has_main_frame_referrer();
+  if (main_frame_referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    main_frame_referrer_ = new ::std::string;
+  }
+  main_frame_referrer_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.URLChainEntry.main_frame_referrer)
+}
+inline void ClientDownloadRequest_URLChainEntry::set_main_frame_referrer(const char* value, size_t size) {
+  set_has_main_frame_referrer();
+  if (main_frame_referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    main_frame_referrer_ = new ::std::string;
+  }
+  main_frame_referrer_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.URLChainEntry.main_frame_referrer)
+}
+inline ::std::string* ClientDownloadRequest_URLChainEntry::mutable_main_frame_referrer() {
+  set_has_main_frame_referrer();
+  if (main_frame_referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    main_frame_referrer_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.URLChainEntry.main_frame_referrer)
+  return main_frame_referrer_;
+}
+inline ::std::string* ClientDownloadRequest_URLChainEntry::release_main_frame_referrer() {
+  clear_has_main_frame_referrer();
+  if (main_frame_referrer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = main_frame_referrer_;
+    main_frame_referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest_URLChainEntry::set_allocated_main_frame_referrer(::std::string* main_frame_referrer) {
+  if (main_frame_referrer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete main_frame_referrer_;
+  }
+  if (main_frame_referrer) {
+    set_has_main_frame_referrer();
+    main_frame_referrer_ = main_frame_referrer;
+  } else {
+    clear_has_main_frame_referrer();
+    main_frame_referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.URLChainEntry.main_frame_referrer)
+}
+
+// optional bool is_retargeting = 6;
+inline bool ClientDownloadRequest_URLChainEntry::has_is_retargeting() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_has_is_retargeting() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_has_is_retargeting() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_is_retargeting() {
+  is_retargeting_ = false;
+  clear_has_is_retargeting();
+}
+inline bool ClientDownloadRequest_URLChainEntry::is_retargeting() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.URLChainEntry.is_retargeting)
+  return is_retargeting_;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_is_retargeting(bool value) {
+  set_has_is_retargeting();
+  is_retargeting_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.URLChainEntry.is_retargeting)
+}
+
+// optional bool is_user_initiated = 7;
+inline bool ClientDownloadRequest_URLChainEntry::has_is_user_initiated() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_has_is_user_initiated() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_has_is_user_initiated() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_is_user_initiated() {
+  is_user_initiated_ = false;
+  clear_has_is_user_initiated();
+}
+inline bool ClientDownloadRequest_URLChainEntry::is_user_initiated() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.URLChainEntry.is_user_initiated)
+  return is_user_initiated_;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_is_user_initiated(bool value) {
+  set_has_is_user_initiated();
+  is_user_initiated_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.URLChainEntry.is_user_initiated)
+}
+
+// optional double timestamp_in_millisec = 8;
+inline bool ClientDownloadRequest_URLChainEntry::has_timestamp_in_millisec() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_has_timestamp_in_millisec() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_has_timestamp_in_millisec() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClientDownloadRequest_URLChainEntry::clear_timestamp_in_millisec() {
+  timestamp_in_millisec_ = 0;
+  clear_has_timestamp_in_millisec();
+}
+inline double ClientDownloadRequest_URLChainEntry::timestamp_in_millisec() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.URLChainEntry.timestamp_in_millisec)
+  return timestamp_in_millisec_;
+}
+inline void ClientDownloadRequest_URLChainEntry::set_timestamp_in_millisec(double value) {
+  set_has_timestamp_in_millisec();
+  timestamp_in_millisec_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.URLChainEntry.timestamp_in_millisec)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadRequest
+
+// required string url = 1;
+inline bool ClientDownloadRequest::has_url() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadRequest::set_has_url() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadRequest::clear_has_url() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadRequest::clear_url() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_->clear();
+  }
+  clear_has_url();
+}
+inline const ::std::string& ClientDownloadRequest::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.url)
+  return *url_;
+}
+inline void ClientDownloadRequest::set_url(const ::std::string& value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.url)
+}
+inline void ClientDownloadRequest::set_url(const char* value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.url)
+}
+inline void ClientDownloadRequest::set_url(const char* value, size_t size) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.url)
+}
+inline ::std::string* ClientDownloadRequest::mutable_url() {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.url)
+  return url_;
+}
+inline ::std::string* ClientDownloadRequest::release_url() {
+  clear_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_;
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest::set_allocated_url(::std::string* url) {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (url) {
+    set_has_url();
+    url_ = url;
+  } else {
+    clear_has_url();
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.url)
+}
+
+// required .safe_browsing.ClientDownloadRequest.Digests digests = 2;
+inline bool ClientDownloadRequest::has_digests() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientDownloadRequest::set_has_digests() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientDownloadRequest::clear_has_digests() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientDownloadRequest::clear_digests() {
+  if (digests_ != NULL) digests_->::safe_browsing::ClientDownloadRequest_Digests::Clear();
+  clear_has_digests();
+}
+inline const ::safe_browsing::ClientDownloadRequest_Digests& ClientDownloadRequest::digests() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.digests)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return digests_ != NULL ? *digests_ : *default_instance().digests_;
+#else
+  return digests_ != NULL ? *digests_ : *default_instance_->digests_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest::mutable_digests() {
+  set_has_digests();
+  if (digests_ == NULL) digests_ = new ::safe_browsing::ClientDownloadRequest_Digests;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.digests)
+  return digests_;
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest::release_digests() {
+  clear_has_digests();
+  ::safe_browsing::ClientDownloadRequest_Digests* temp = digests_;
+  digests_ = NULL;
+  return temp;
+}
+inline void ClientDownloadRequest::set_allocated_digests(::safe_browsing::ClientDownloadRequest_Digests* digests) {
+  delete digests_;
+  digests_ = digests;
+  if (digests) {
+    set_has_digests();
+  } else {
+    clear_has_digests();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.digests)
+}
+
+// required int64 length = 3;
+inline bool ClientDownloadRequest::has_length() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientDownloadRequest::set_has_length() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientDownloadRequest::clear_has_length() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientDownloadRequest::clear_length() {
+  length_ = GOOGLE_LONGLONG(0);
+  clear_has_length();
+}
+inline ::google::protobuf::int64 ClientDownloadRequest::length() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.length)
+  return length_;
+}
+inline void ClientDownloadRequest::set_length(::google::protobuf::int64 value) {
+  set_has_length();
+  length_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.length)
+}
+
+// repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4;
+inline int ClientDownloadRequest::resources_size() const {
+  return resources_.size();
+}
+inline void ClientDownloadRequest::clear_resources() {
+  resources_.Clear();
+}
+inline const ::safe_browsing::ClientDownloadRequest_Resource& ClientDownloadRequest::resources(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.resources)
+  return resources_.Get(index);
+}
+inline ::safe_browsing::ClientDownloadRequest_Resource* ClientDownloadRequest::mutable_resources(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.resources)
+  return resources_.Mutable(index);
+}
+inline ::safe_browsing::ClientDownloadRequest_Resource* ClientDownloadRequest::add_resources() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.resources)
+  return resources_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource >&
+ClientDownloadRequest::resources() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.resources)
+  return resources_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource >*
+ClientDownloadRequest::mutable_resources() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.resources)
+  return &resources_;
+}
+
+// optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+inline bool ClientDownloadRequest::has_signature() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientDownloadRequest::set_has_signature() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientDownloadRequest::clear_has_signature() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientDownloadRequest::clear_signature() {
+  if (signature_ != NULL) signature_->::safe_browsing::ClientDownloadRequest_SignatureInfo::Clear();
+  clear_has_signature();
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientDownloadRequest::signature() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.signature)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return signature_ != NULL ? *signature_ : *default_instance().signature_;
+#else
+  return signature_ != NULL ? *signature_ : *default_instance_->signature_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest::mutable_signature() {
+  set_has_signature();
+  if (signature_ == NULL) signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.signature)
+  return signature_;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest::release_signature() {
+  clear_has_signature();
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = signature_;
+  signature_ = NULL;
+  return temp;
+}
+inline void ClientDownloadRequest::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  delete signature_;
+  signature_ = signature;
+  if (signature) {
+    set_has_signature();
+  } else {
+    clear_has_signature();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.signature)
+}
+
+// optional bool user_initiated = 6;
+inline bool ClientDownloadRequest::has_user_initiated() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClientDownloadRequest::set_has_user_initiated() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClientDownloadRequest::clear_has_user_initiated() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClientDownloadRequest::clear_user_initiated() {
+  user_initiated_ = false;
+  clear_has_user_initiated();
+}
+inline bool ClientDownloadRequest::user_initiated() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.user_initiated)
+  return user_initiated_;
+}
+inline void ClientDownloadRequest::set_user_initiated(bool value) {
+  set_has_user_initiated();
+  user_initiated_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.user_initiated)
+}
+
+// optional string file_basename = 9;
+inline bool ClientDownloadRequest::has_file_basename() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClientDownloadRequest::set_has_file_basename() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClientDownloadRequest::clear_has_file_basename() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClientDownloadRequest::clear_file_basename() {
+  if (file_basename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_->clear();
+  }
+  clear_has_file_basename();
+}
+inline const ::std::string& ClientDownloadRequest::file_basename() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.file_basename)
+  return *file_basename_;
+}
+inline void ClientDownloadRequest::set_file_basename(const ::std::string& value) {
+  set_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_ = new ::std::string;
+  }
+  file_basename_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.file_basename)
+}
+inline void ClientDownloadRequest::set_file_basename(const char* value) {
+  set_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_ = new ::std::string;
+  }
+  file_basename_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.file_basename)
+}
+inline void ClientDownloadRequest::set_file_basename(const char* value, size_t size) {
+  set_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_ = new ::std::string;
+  }
+  file_basename_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.file_basename)
+}
+inline ::std::string* ClientDownloadRequest::mutable_file_basename() {
+  set_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.file_basename)
+  return file_basename_;
+}
+inline ::std::string* ClientDownloadRequest::release_file_basename() {
+  clear_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = file_basename_;
+    file_basename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest::set_allocated_file_basename(::std::string* file_basename) {
+  if (file_basename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete file_basename_;
+  }
+  if (file_basename) {
+    set_has_file_basename();
+    file_basename_ = file_basename;
+  } else {
+    clear_has_file_basename();
+    file_basename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::has_download_type() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClientDownloadRequest::set_has_download_type() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClientDownloadRequest::clear_has_download_type() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClientDownloadRequest::clear_download_type() {
+  download_type_ = 0;
+  clear_has_download_type();
+}
+inline ::safe_browsing::ClientDownloadRequest_DownloadType ClientDownloadRequest::download_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.download_type)
+  return static_cast< ::safe_browsing::ClientDownloadRequest_DownloadType >(download_type_);
+}
+inline void ClientDownloadRequest::set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value) {
+  assert(::safe_browsing::ClientDownloadRequest_DownloadType_IsValid(value));
+  set_has_download_type();
+  download_type_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.download_type)
+}
+
+// optional string locale = 11;
+inline bool ClientDownloadRequest::has_locale() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ClientDownloadRequest::set_has_locale() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ClientDownloadRequest::clear_has_locale() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ClientDownloadRequest::clear_locale() {
+  if (locale_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    locale_->clear();
+  }
+  clear_has_locale();
+}
+inline const ::std::string& ClientDownloadRequest::locale() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.locale)
+  return *locale_;
+}
+inline void ClientDownloadRequest::set_locale(const ::std::string& value) {
+  set_has_locale();
+  if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    locale_ = new ::std::string;
+  }
+  locale_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.locale)
+}
+inline void ClientDownloadRequest::set_locale(const char* value) {
+  set_has_locale();
+  if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    locale_ = new ::std::string;
+  }
+  locale_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadRequest.locale)
+}
+inline void ClientDownloadRequest::set_locale(const char* value, size_t size) {
+  set_has_locale();
+  if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    locale_ = new ::std::string;
+  }
+  locale_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadRequest.locale)
+}
+inline ::std::string* ClientDownloadRequest::mutable_locale() {
+  set_has_locale();
+  if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    locale_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.locale)
+  return locale_;
+}
+inline ::std::string* ClientDownloadRequest::release_locale() {
+  clear_has_locale();
+  if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = locale_;
+    locale_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadRequest::set_allocated_locale(::std::string* locale) {
+  if (locale_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete locale_;
+  }
+  if (locale) {
+    set_has_locale();
+    locale_ = locale;
+  } else {
+    clear_has_locale();
+    locale_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.locale)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 18;
+inline bool ClientDownloadRequest::has_image_headers() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void ClientDownloadRequest::set_has_image_headers() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void ClientDownloadRequest::clear_has_image_headers() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void ClientDownloadRequest::clear_image_headers() {
+  if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+  clear_has_image_headers();
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientDownloadRequest::image_headers() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.image_headers)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return image_headers_ != NULL ? *image_headers_ : *default_instance().image_headers_;
+#else
+  return image_headers_ != NULL ? *image_headers_ : *default_instance_->image_headers_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest::mutable_image_headers() {
+  set_has_image_headers();
+  if (image_headers_ == NULL) image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.image_headers)
+  return image_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientDownloadRequest::release_image_headers() {
+  clear_has_image_headers();
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = image_headers_;
+  image_headers_ = NULL;
+  return temp;
+}
+inline void ClientDownloadRequest::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  delete image_headers_;
+  image_headers_ = image_headers;
+  if (image_headers) {
+    set_has_image_headers();
+  } else {
+    clear_has_image_headers();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.image_headers)
+}
+
+// repeated .safe_browsing.ClientDownloadRequest.ArchivedBinary archived_binary = 22;
+inline int ClientDownloadRequest::archived_binary_size() const {
+  return archived_binary_.size();
+}
+inline void ClientDownloadRequest::clear_archived_binary() {
+  archived_binary_.Clear();
+}
+inline const ::safe_browsing::ClientDownloadRequest_ArchivedBinary& ClientDownloadRequest::archived_binary(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.archived_binary)
+  return archived_binary_.Get(index);
+}
+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 ::safe_browsing::ClientDownloadRequest_ArchivedBinary* ClientDownloadRequest::add_archived_binary() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.archived_binary)
+  return archived_binary_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ArchivedBinary >&
+ClientDownloadRequest::archived_binary() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.archived_binary)
+  return archived_binary_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_ArchivedBinary >*
+ClientDownloadRequest::mutable_archived_binary() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.archived_binary)
+  return &archived_binary_;
+}
+
+// optional .safe_browsing.ChromeUserPopulation population = 24;
+inline bool ClientDownloadRequest::has_population() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void ClientDownloadRequest::set_has_population() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void ClientDownloadRequest::clear_has_population() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void ClientDownloadRequest::clear_population() {
+  if (population_ != NULL) population_->::safe_browsing::ChromeUserPopulation::Clear();
+  clear_has_population();
+}
+inline const ::safe_browsing::ChromeUserPopulation& ClientDownloadRequest::population() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.population)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return population_ != NULL ? *population_ : *default_instance().population_;
+#else
+  return population_ != NULL ? *population_ : *default_instance_->population_;
+#endif
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientDownloadRequest::mutable_population() {
+  set_has_population();
+  if (population_ == NULL) population_ = new ::safe_browsing::ChromeUserPopulation;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.population)
+  return population_;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientDownloadRequest::release_population() {
+  clear_has_population();
+  ::safe_browsing::ChromeUserPopulation* temp = population_;
+  population_ = NULL;
+  return temp;
+}
+inline void ClientDownloadRequest::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) {
+  delete population_;
+  population_ = population;
+  if (population) {
+    set_has_population();
+  } else {
+    clear_has_population();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadRequest.population)
+}
+
+// optional bool archive_valid = 26;
+inline bool ClientDownloadRequest::has_archive_valid() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void ClientDownloadRequest::set_has_archive_valid() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void ClientDownloadRequest::clear_has_archive_valid() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void ClientDownloadRequest::clear_archive_valid() {
+  archive_valid_ = false;
+  clear_has_archive_valid();
+}
+inline bool ClientDownloadRequest::archive_valid() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.archive_valid)
+  return archive_valid_;
+}
+inline void ClientDownloadRequest::set_archive_valid(bool value) {
+  set_has_archive_valid();
+  archive_valid_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.archive_valid)
+}
+
+// optional bool skipped_url_whitelist = 28;
+inline bool ClientDownloadRequest::has_skipped_url_whitelist() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void ClientDownloadRequest::set_has_skipped_url_whitelist() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void ClientDownloadRequest::clear_has_skipped_url_whitelist() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void ClientDownloadRequest::clear_skipped_url_whitelist() {
+  skipped_url_whitelist_ = false;
+  clear_has_skipped_url_whitelist();
+}
+inline bool ClientDownloadRequest::skipped_url_whitelist() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.skipped_url_whitelist)
+  return skipped_url_whitelist_;
+}
+inline void ClientDownloadRequest::set_skipped_url_whitelist(bool value) {
+  set_has_skipped_url_whitelist();
+  skipped_url_whitelist_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.skipped_url_whitelist)
+}
+
+// optional bool skipped_certificate_whitelist = 31;
+inline bool ClientDownloadRequest::has_skipped_certificate_whitelist() const {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void ClientDownloadRequest::set_has_skipped_certificate_whitelist() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void ClientDownloadRequest::clear_has_skipped_certificate_whitelist() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void ClientDownloadRequest::clear_skipped_certificate_whitelist() {
+  skipped_certificate_whitelist_ = false;
+  clear_has_skipped_certificate_whitelist();
+}
+inline bool ClientDownloadRequest::skipped_certificate_whitelist() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.skipped_certificate_whitelist)
+  return skipped_certificate_whitelist_;
+}
+inline void ClientDownloadRequest::set_skipped_certificate_whitelist(bool value) {
+  set_has_skipped_certificate_whitelist();
+  skipped_certificate_whitelist_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadRequest.skipped_certificate_whitelist)
+}
+
+// repeated string alternate_extensions = 35;
+inline int ClientDownloadRequest::alternate_extensions_size() const {
+  return alternate_extensions_.size();
+}
+inline void ClientDownloadRequest::clear_alternate_extensions() {
+  alternate_extensions_.Clear();
+}
+inline const ::std::string& ClientDownloadRequest::alternate_extensions(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.alternate_extensions)
+  return alternate_extensions_.Get(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, const char* value) {
+  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::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(const char* value) {
+  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 ::google::protobuf::RepeatedPtrField< ::std::string>&
+ClientDownloadRequest::alternate_extensions() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.alternate_extensions)
+  return alternate_extensions_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+ClientDownloadRequest::mutable_alternate_extensions() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.alternate_extensions)
+  return &alternate_extensions_;
+}
+
+// repeated .safe_browsing.ClientDownloadRequest.URLChainEntry url_chain = 36;
+inline int ClientDownloadRequest::url_chain_size() const {
+  return url_chain_.size();
+}
+inline void ClientDownloadRequest::clear_url_chain() {
+  url_chain_.Clear();
+}
+inline const ::safe_browsing::ClientDownloadRequest_URLChainEntry& ClientDownloadRequest::url_chain(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadRequest.url_chain)
+  return url_chain_.Get(index);
+}
+inline ::safe_browsing::ClientDownloadRequest_URLChainEntry* ClientDownloadRequest::mutable_url_chain(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadRequest.url_chain)
+  return url_chain_.Mutable(index);
+}
+inline ::safe_browsing::ClientDownloadRequest_URLChainEntry* ClientDownloadRequest::add_url_chain() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientDownloadRequest.url_chain)
+  return url_chain_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_URLChainEntry >&
+ClientDownloadRequest::url_chain() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientDownloadRequest.url_chain)
+  return url_chain_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_URLChainEntry >*
+ClientDownloadRequest::mutable_url_chain() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientDownloadRequest.url_chain)
+  return &url_chain_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadResponse_MoreInfo
+
+// optional string description = 1;
+inline bool ClientDownloadResponse_MoreInfo::has_description() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadResponse_MoreInfo::set_has_description() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadResponse_MoreInfo::clear_has_description() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadResponse_MoreInfo::clear_description() {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_->clear();
+  }
+  clear_has_description();
+}
+inline const ::std::string& ClientDownloadResponse_MoreInfo::description() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadResponse.MoreInfo.description)
+  return *description_;
+}
+inline void ClientDownloadResponse_MoreInfo::set_description(const ::std::string& value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadResponse.MoreInfo.description)
+}
+inline void ClientDownloadResponse_MoreInfo::set_description(const char* value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadResponse.MoreInfo.description)
+}
+inline void ClientDownloadResponse_MoreInfo::set_description(const char* value, size_t size) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadResponse.MoreInfo.description)
+}
+inline ::std::string* ClientDownloadResponse_MoreInfo::mutable_description() {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadResponse.MoreInfo.description)
+  return description_;
+}
+inline ::std::string* ClientDownloadResponse_MoreInfo::release_description() {
+  clear_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = description_;
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadResponse_MoreInfo::set_allocated_description(::std::string* description) {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (description) {
+    set_has_description();
+    description_ = description;
+  } else {
+    clear_has_description();
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadResponse.MoreInfo.description)
+}
+
+// optional string url = 2;
+inline bool ClientDownloadResponse_MoreInfo::has_url() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientDownloadResponse_MoreInfo::set_has_url() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientDownloadResponse_MoreInfo::clear_has_url() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientDownloadResponse_MoreInfo::clear_url() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_->clear();
+  }
+  clear_has_url();
+}
+inline const ::std::string& ClientDownloadResponse_MoreInfo::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadResponse.MoreInfo.url)
+  return *url_;
+}
+inline void ClientDownloadResponse_MoreInfo::set_url(const ::std::string& value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadResponse.MoreInfo.url)
+}
+inline void ClientDownloadResponse_MoreInfo::set_url(const char* value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadResponse.MoreInfo.url)
+}
+inline void ClientDownloadResponse_MoreInfo::set_url(const char* value, size_t size) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadResponse.MoreInfo.url)
+}
+inline ::std::string* ClientDownloadResponse_MoreInfo::mutable_url() {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadResponse.MoreInfo.url)
+  return url_;
+}
+inline ::std::string* ClientDownloadResponse_MoreInfo::release_url() {
+  clear_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_;
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadResponse_MoreInfo::set_allocated_url(::std::string* url) {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (url) {
+    set_has_url();
+    url_ = url;
+  } else {
+    clear_has_url();
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadResponse.MoreInfo.url)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadResponse
+
+// optional .safe_browsing.ClientDownloadResponse.Verdict verdict = 1 [default = SAFE];
+inline bool ClientDownloadResponse::has_verdict() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadResponse::set_has_verdict() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadResponse::clear_has_verdict() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadResponse::clear_verdict() {
+  verdict_ = 0;
+  clear_has_verdict();
+}
+inline ::safe_browsing::ClientDownloadResponse_Verdict ClientDownloadResponse::verdict() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadResponse.verdict)
+  return static_cast< ::safe_browsing::ClientDownloadResponse_Verdict >(verdict_);
+}
+inline void ClientDownloadResponse::set_verdict(::safe_browsing::ClientDownloadResponse_Verdict value) {
+  assert(::safe_browsing::ClientDownloadResponse_Verdict_IsValid(value));
+  set_has_verdict();
+  verdict_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadResponse.verdict)
+}
+
+// optional .safe_browsing.ClientDownloadResponse.MoreInfo more_info = 2;
+inline bool ClientDownloadResponse::has_more_info() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientDownloadResponse::set_has_more_info() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientDownloadResponse::clear_has_more_info() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientDownloadResponse::clear_more_info() {
+  if (more_info_ != NULL) more_info_->::safe_browsing::ClientDownloadResponse_MoreInfo::Clear();
+  clear_has_more_info();
+}
+inline const ::safe_browsing::ClientDownloadResponse_MoreInfo& ClientDownloadResponse::more_info() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadResponse.more_info)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return more_info_ != NULL ? *more_info_ : *default_instance().more_info_;
+#else
+  return more_info_ != NULL ? *more_info_ : *default_instance_->more_info_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadResponse_MoreInfo* ClientDownloadResponse::mutable_more_info() {
+  set_has_more_info();
+  if (more_info_ == NULL) more_info_ = new ::safe_browsing::ClientDownloadResponse_MoreInfo;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadResponse.more_info)
+  return more_info_;
+}
+inline ::safe_browsing::ClientDownloadResponse_MoreInfo* ClientDownloadResponse::release_more_info() {
+  clear_has_more_info();
+  ::safe_browsing::ClientDownloadResponse_MoreInfo* temp = more_info_;
+  more_info_ = NULL;
+  return temp;
+}
+inline void ClientDownloadResponse::set_allocated_more_info(::safe_browsing::ClientDownloadResponse_MoreInfo* more_info) {
+  delete more_info_;
+  more_info_ = more_info;
+  if (more_info) {
+    set_has_more_info();
+  } else {
+    clear_has_more_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadResponse.more_info)
+}
+
+// optional bytes token = 3;
+inline bool ClientDownloadResponse::has_token() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientDownloadResponse::set_has_token() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientDownloadResponse::clear_has_token() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientDownloadResponse::clear_token() {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_->clear();
+  }
+  clear_has_token();
+}
+inline const ::std::string& ClientDownloadResponse::token() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadResponse.token)
+  return *token_;
+}
+inline void ClientDownloadResponse::set_token(const ::std::string& value) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadResponse.token)
+}
+inline void ClientDownloadResponse::set_token(const char* value) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadResponse.token)
+}
+inline void ClientDownloadResponse::set_token(const void* value, size_t size) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadResponse.token)
+}
+inline ::std::string* ClientDownloadResponse::mutable_token() {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadResponse.token)
+  return token_;
+}
+inline ::std::string* ClientDownloadResponse::release_token() {
+  clear_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = token_;
+    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadResponse::set_allocated_token(::std::string* token) {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete token_;
+  }
+  if (token) {
+    set_has_token();
+    token_ = token;
+  } else {
+    clear_has_token();
+    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadResponse.token)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadReport_UserInformation
+
+// optional string email = 1;
+inline bool ClientDownloadReport_UserInformation::has_email() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadReport_UserInformation::set_has_email() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadReport_UserInformation::clear_has_email() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadReport_UserInformation::clear_email() {
+  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    email_->clear();
+  }
+  clear_has_email();
+}
+inline const ::std::string& ClientDownloadReport_UserInformation::email() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadReport.UserInformation.email)
+  return *email_;
+}
+inline void ClientDownloadReport_UserInformation::set_email(const ::std::string& value) {
+  set_has_email();
+  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    email_ = new ::std::string;
+  }
+  email_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadReport.UserInformation.email)
+}
+inline void ClientDownloadReport_UserInformation::set_email(const char* value) {
+  set_has_email();
+  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    email_ = new ::std::string;
+  }
+  email_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadReport.UserInformation.email)
+}
+inline void ClientDownloadReport_UserInformation::set_email(const char* value, size_t size) {
+  set_has_email();
+  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    email_ = new ::std::string;
+  }
+  email_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadReport.UserInformation.email)
+}
+inline ::std::string* ClientDownloadReport_UserInformation::mutable_email() {
+  set_has_email();
+  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    email_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.UserInformation.email)
+  return email_;
+}
+inline ::std::string* ClientDownloadReport_UserInformation::release_email() {
+  clear_has_email();
+  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = email_;
+    email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadReport_UserInformation::set_allocated_email(::std::string* email) {
+  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete email_;
+  }
+  if (email) {
+    set_has_email();
+    email_ = email;
+  } else {
+    clear_has_email();
+    email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadReport.UserInformation.email)
+}
+
+// -------------------------------------------------------------------
+
+// ClientDownloadReport
+
+// optional .safe_browsing.ClientDownloadReport.Reason reason = 1;
+inline bool ClientDownloadReport::has_reason() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientDownloadReport::set_has_reason() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientDownloadReport::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientDownloadReport::clear_reason() {
+  reason_ = 0;
+  clear_has_reason();
+}
+inline ::safe_browsing::ClientDownloadReport_Reason ClientDownloadReport::reason() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadReport.reason)
+  return static_cast< ::safe_browsing::ClientDownloadReport_Reason >(reason_);
+}
+inline void ClientDownloadReport::set_reason(::safe_browsing::ClientDownloadReport_Reason value) {
+  assert(::safe_browsing::ClientDownloadReport_Reason_IsValid(value));
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadReport.reason)
+}
+
+// optional .safe_browsing.ClientDownloadRequest download_request = 2;
+inline bool ClientDownloadReport::has_download_request() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientDownloadReport::set_has_download_request() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientDownloadReport::clear_has_download_request() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientDownloadReport::clear_download_request() {
+  if (download_request_ != NULL) download_request_->::safe_browsing::ClientDownloadRequest::Clear();
+  clear_has_download_request();
+}
+inline const ::safe_browsing::ClientDownloadRequest& ClientDownloadReport::download_request() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadReport.download_request)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return download_request_ != NULL ? *download_request_ : *default_instance().download_request_;
+#else
+  return download_request_ != NULL ? *download_request_ : *default_instance_->download_request_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest* ClientDownloadReport::mutable_download_request() {
+  set_has_download_request();
+  if (download_request_ == NULL) download_request_ = new ::safe_browsing::ClientDownloadRequest;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.download_request)
+  return download_request_;
+}
+inline ::safe_browsing::ClientDownloadRequest* ClientDownloadReport::release_download_request() {
+  clear_has_download_request();
+  ::safe_browsing::ClientDownloadRequest* temp = download_request_;
+  download_request_ = NULL;
+  return temp;
+}
+inline void ClientDownloadReport::set_allocated_download_request(::safe_browsing::ClientDownloadRequest* download_request) {
+  delete download_request_;
+  download_request_ = download_request;
+  if (download_request) {
+    set_has_download_request();
+  } else {
+    clear_has_download_request();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadReport.download_request)
+}
+
+// optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3;
+inline bool ClientDownloadReport::has_user_information() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientDownloadReport::set_has_user_information() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientDownloadReport::clear_has_user_information() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientDownloadReport::clear_user_information() {
+  if (user_information_ != NULL) user_information_->::safe_browsing::ClientDownloadReport_UserInformation::Clear();
+  clear_has_user_information();
+}
+inline const ::safe_browsing::ClientDownloadReport_UserInformation& ClientDownloadReport::user_information() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadReport.user_information)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return user_information_ != NULL ? *user_information_ : *default_instance().user_information_;
+#else
+  return user_information_ != NULL ? *user_information_ : *default_instance_->user_information_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadReport_UserInformation* ClientDownloadReport::mutable_user_information() {
+  set_has_user_information();
+  if (user_information_ == NULL) user_information_ = new ::safe_browsing::ClientDownloadReport_UserInformation;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.user_information)
+  return user_information_;
+}
+inline ::safe_browsing::ClientDownloadReport_UserInformation* ClientDownloadReport::release_user_information() {
+  clear_has_user_information();
+  ::safe_browsing::ClientDownloadReport_UserInformation* temp = user_information_;
+  user_information_ = NULL;
+  return temp;
+}
+inline void ClientDownloadReport::set_allocated_user_information(::safe_browsing::ClientDownloadReport_UserInformation* user_information) {
+  delete user_information_;
+  user_information_ = user_information;
+  if (user_information) {
+    set_has_user_information();
+  } else {
+    clear_has_user_information();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadReport.user_information)
+}
+
+// optional bytes comment = 4;
+inline bool ClientDownloadReport::has_comment() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientDownloadReport::set_has_comment() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientDownloadReport::clear_has_comment() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientDownloadReport::clear_comment() {
+  if (comment_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    comment_->clear();
+  }
+  clear_has_comment();
+}
+inline const ::std::string& ClientDownloadReport::comment() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadReport.comment)
+  return *comment_;
+}
+inline void ClientDownloadReport::set_comment(const ::std::string& value) {
+  set_has_comment();
+  if (comment_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    comment_ = new ::std::string;
+  }
+  comment_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientDownloadReport.comment)
+}
+inline void ClientDownloadReport::set_comment(const char* value) {
+  set_has_comment();
+  if (comment_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    comment_ = new ::std::string;
+  }
+  comment_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientDownloadReport.comment)
+}
+inline void ClientDownloadReport::set_comment(const void* value, size_t size) {
+  set_has_comment();
+  if (comment_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    comment_ = new ::std::string;
+  }
+  comment_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientDownloadReport.comment)
+}
+inline ::std::string* ClientDownloadReport::mutable_comment() {
+  set_has_comment();
+  if (comment_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    comment_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.comment)
+  return comment_;
+}
+inline ::std::string* ClientDownloadReport::release_comment() {
+  clear_has_comment();
+  if (comment_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = comment_;
+    comment_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientDownloadReport::set_allocated_comment(::std::string* comment) {
+  if (comment_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete comment_;
+  }
+  if (comment) {
+    set_has_comment();
+    comment_ = comment;
+  } else {
+    clear_has_comment();
+    comment_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadReport.comment)
+}
+
+// optional .safe_browsing.ClientDownloadResponse download_response = 5;
+inline bool ClientDownloadReport::has_download_response() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientDownloadReport::set_has_download_response() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientDownloadReport::clear_has_download_response() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientDownloadReport::clear_download_response() {
+  if (download_response_ != NULL) download_response_->::safe_browsing::ClientDownloadResponse::Clear();
+  clear_has_download_response();
+}
+inline const ::safe_browsing::ClientDownloadResponse& ClientDownloadReport::download_response() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientDownloadReport.download_response)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return download_response_ != NULL ? *download_response_ : *default_instance().download_response_;
+#else
+  return download_response_ != NULL ? *download_response_ : *default_instance_->download_response_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadResponse* ClientDownloadReport::mutable_download_response() {
+  set_has_download_response();
+  if (download_response_ == NULL) download_response_ = new ::safe_browsing::ClientDownloadResponse;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientDownloadReport.download_response)
+  return download_response_;
+}
+inline ::safe_browsing::ClientDownloadResponse* ClientDownloadReport::release_download_response() {
+  clear_has_download_response();
+  ::safe_browsing::ClientDownloadResponse* temp = download_response_;
+  download_response_ = NULL;
+  return temp;
+}
+inline void ClientDownloadReport::set_allocated_download_response(::safe_browsing::ClientDownloadResponse* download_response) {
+  delete download_response_;
+  download_response_ = download_response;
+  if (download_response) {
+    set_has_download_response();
+  } else {
+    clear_has_download_response();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientDownloadReport.download_response)
+}
+
+// -------------------------------------------------------------------
+
+// ClientUploadResponse
+
+// optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1;
+inline bool ClientUploadResponse::has_status() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientUploadResponse::set_has_status() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientUploadResponse::clear_has_status() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientUploadResponse::clear_status() {
+  status_ = 0;
+  clear_has_status();
+}
+inline ::safe_browsing::ClientUploadResponse_UploadStatus ClientUploadResponse::status() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientUploadResponse.status)
+  return static_cast< ::safe_browsing::ClientUploadResponse_UploadStatus >(status_);
+}
+inline void ClientUploadResponse::set_status(::safe_browsing::ClientUploadResponse_UploadStatus value) {
+  assert(::safe_browsing::ClientUploadResponse_UploadStatus_IsValid(value));
+  set_has_status();
+  status_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientUploadResponse.status)
+}
+
+// optional string permalink = 2;
+inline bool ClientUploadResponse::has_permalink() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientUploadResponse::set_has_permalink() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientUploadResponse::clear_has_permalink() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientUploadResponse::clear_permalink() {
+  if (permalink_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    permalink_->clear();
+  }
+  clear_has_permalink();
+}
+inline const ::std::string& ClientUploadResponse::permalink() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientUploadResponse.permalink)
+  return *permalink_;
+}
+inline void ClientUploadResponse::set_permalink(const ::std::string& value) {
+  set_has_permalink();
+  if (permalink_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    permalink_ = new ::std::string;
+  }
+  permalink_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientUploadResponse.permalink)
+}
+inline void ClientUploadResponse::set_permalink(const char* value) {
+  set_has_permalink();
+  if (permalink_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    permalink_ = new ::std::string;
+  }
+  permalink_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientUploadResponse.permalink)
+}
+inline void ClientUploadResponse::set_permalink(const char* value, size_t size) {
+  set_has_permalink();
+  if (permalink_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    permalink_ = new ::std::string;
+  }
+  permalink_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientUploadResponse.permalink)
+}
+inline ::std::string* ClientUploadResponse::mutable_permalink() {
+  set_has_permalink();
+  if (permalink_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    permalink_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientUploadResponse.permalink)
+  return permalink_;
+}
+inline ::std::string* ClientUploadResponse::release_permalink() {
+  clear_has_permalink();
+  if (permalink_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = permalink_;
+    permalink_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientUploadResponse::set_allocated_permalink(::std::string* permalink) {
+  if (permalink_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete permalink_;
+  }
+  if (permalink) {
+    set_has_permalink();
+    permalink_ = permalink;
+  } else {
+    clear_has_permalink();
+    permalink_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientUploadResponse.permalink)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_IncidentData_TrackedPreferenceIncident
+
+// optional string path = 1;
+inline bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident::has_path() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_has_path() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::clear_has_path() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::clear_path() {
+  if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_->clear();
+  }
+  clear_has_path();
+}
+inline const ::std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident::path() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path)
+  return *path_;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_path(const ::std::string& value) {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  path_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path)
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_path(const char* value) {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  path_->assign(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) {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  path_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path)
+}
+inline ::std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::mutable_path() {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path)
+  return path_;
+}
+inline ::std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::release_path() {
+  clear_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = path_;
+    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_allocated_path(::std::string* path) {
+  if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete path_;
+  }
+  if (path) {
+    set_has_path();
+    path_ = path;
+  } else {
+    clear_has_path();
+    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.path)
+}
+
+// optional string atomic_value = 2;
+inline bool ClientIncidentReport_IncidentData_TrackedPreferenceIncident::has_atomic_value() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_has_atomic_value() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::clear_has_atomic_value() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::clear_atomic_value() {
+  if (atomic_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    atomic_value_->clear();
+  }
+  clear_has_atomic_value();
+}
+inline const ::std::string& ClientIncidentReport_IncidentData_TrackedPreferenceIncident::atomic_value() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value)
+  return *atomic_value_;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_atomic_value(const ::std::string& value) {
+  set_has_atomic_value();
+  if (atomic_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    atomic_value_ = new ::std::string;
+  }
+  atomic_value_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value)
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_atomic_value(const char* value) {
+  set_has_atomic_value();
+  if (atomic_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    atomic_value_ = new ::std::string;
+  }
+  atomic_value_->assign(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) {
+  set_has_atomic_value();
+  if (atomic_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    atomic_value_ = new ::std::string;
+  }
+  atomic_value_->assign(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::mutable_atomic_value() {
+  set_has_atomic_value();
+  if (atomic_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    atomic_value_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value)
+  return atomic_value_;
+}
+inline ::std::string* ClientIncidentReport_IncidentData_TrackedPreferenceIncident::release_atomic_value() {
+  clear_has_atomic_value();
+  if (atomic_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = atomic_value_;
+    atomic_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_allocated_atomic_value(::std::string* atomic_value) {
+  if (atomic_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete atomic_value_;
+  }
+  if (atomic_value) {
+    set_has_atomic_value();
+    atomic_value_ = atomic_value;
+  } else {
+    clear_has_atomic_value();
+    atomic_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.TrackedPreferenceIncident.atomic_value)
+}
+
+// repeated string split_key = 3;
+inline int ClientIncidentReport_IncidentData_TrackedPreferenceIncident::split_key_size() const {
+  return split_key_.size();
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::clear_split_key() {
+  split_key_.Clear();
+}
+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 split_key_.Get(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, const char* value) {
+  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::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(const char* value) {
+  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 ::google::protobuf::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 ::google::protobuf::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::has_value_state() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_has_value_state() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::clear_has_value_state() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::clear_value_state() {
+  value_state_ = 0;
+  clear_has_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 static_cast< ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState >(value_state_);
+}
+inline void ClientIncidentReport_IncidentData_TrackedPreferenceIncident::set_value_state(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState value) {
+  assert(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident_ValueState_IsValid(value));
+  set_has_value_state();
+  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::has_relative_path() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_has_relative_path() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::clear_has_relative_path() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::clear_relative_path() {
+  if (relative_path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    relative_path_->clear();
+  }
+  clear_has_relative_path();
+}
+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 *relative_path_;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_relative_path(const ::std::string& value) {
+  set_has_relative_path();
+  if (relative_path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    relative_path_ = new ::std::string;
+  }
+  relative_path_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.relative_path)
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_relative_path(const char* value) {
+  set_has_relative_path();
+  if (relative_path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    relative_path_ = new ::std::string;
+  }
+  relative_path_->assign(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) {
+  set_has_relative_path();
+  if (relative_path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    relative_path_ = new ::std::string;
+  }
+  relative_path_->assign(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::mutable_relative_path() {
+  set_has_relative_path();
+  if (relative_path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    relative_path_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.relative_path)
+  return relative_path_;
+}
+inline ::std::string* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::release_relative_path() {
+  clear_has_relative_path();
+  if (relative_path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = relative_path_;
+    relative_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_allocated_relative_path(::std::string* relative_path) {
+  if (relative_path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete relative_path_;
+  }
+  if (relative_path) {
+    set_has_relative_path();
+    relative_path_ = relative_path;
+  } else {
+    clear_has_relative_path();
+    relative_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::has_signature() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_has_signature() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::clear_has_signature() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::clear_signature() {
+  if (signature_ != NULL) signature_->::safe_browsing::ClientDownloadRequest_SignatureInfo::Clear();
+  clear_has_signature();
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::signature() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.signature)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return signature_ != NULL ? *signature_ : *default_instance().signature_;
+#else
+  return signature_ != NULL ? *signature_ : *default_instance_->signature_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::mutable_signature() {
+  set_has_signature();
+  if (signature_ == NULL) signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.signature)
+  return signature_;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::release_signature() {
+  clear_has_signature();
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = signature_;
+  signature_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  delete signature_;
+  signature_ = signature;
+  if (signature) {
+    set_has_signature();
+  } else {
+    clear_has_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::has_image_headers() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_has_image_headers() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::clear_has_image_headers() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::clear_image_headers() {
+  if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+  clear_has_image_headers();
+}
+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)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return image_headers_ != NULL ? *image_headers_ : *default_instance().image_headers_;
+#else
+  return image_headers_ != NULL ? *image_headers_ : *default_instance_->image_headers_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::mutable_image_headers() {
+  set_has_image_headers();
+  if (image_headers_ == NULL) image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.ContainedFile.image_headers)
+  return image_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::release_image_headers() {
+  clear_has_image_headers();
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = image_headers_;
+  image_headers_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident_ContainedFile::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  delete image_headers_;
+  image_headers_ = image_headers;
+  if (image_headers) {
+    set_has_image_headers();
+  } else {
+    clear_has_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::has_file_basename() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_has_file_basename() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_has_file_basename() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_file_basename() {
+  if (file_basename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_->clear();
+  }
+  clear_has_file_basename();
+}
+inline const ::std::string& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::file_basename() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.file_basename)
+  return *file_basename_;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_file_basename(const ::std::string& value) {
+  set_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_ = new ::std::string;
+  }
+  file_basename_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.file_basename)
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_file_basename(const char* value) {
+  set_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_ = new ::std::string;
+  }
+  file_basename_->assign(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) {
+  set_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_ = new ::std::string;
+  }
+  file_basename_->assign(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::mutable_file_basename() {
+  set_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_basename_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.file_basename)
+  return file_basename_;
+}
+inline ::std::string* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::release_file_basename() {
+  clear_has_file_basename();
+  if (file_basename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = file_basename_;
+    file_basename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_allocated_file_basename(::std::string* file_basename) {
+  if (file_basename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete file_basename_;
+  }
+  if (file_basename) {
+    set_has_file_basename();
+    file_basename_ = file_basename;
+  } else {
+    clear_has_file_basename();
+    file_basename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::has_signature() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_has_signature() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_has_signature() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_signature() {
+  if (signature_ != NULL) signature_->::safe_browsing::ClientDownloadRequest_SignatureInfo::Clear();
+  clear_has_signature();
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::signature() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.signature)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return signature_ != NULL ? *signature_ : *default_instance().signature_;
+#else
+  return signature_ != NULL ? *signature_ : *default_instance_->signature_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::mutable_signature() {
+  set_has_signature();
+  if (signature_ == NULL) signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.signature)
+  return signature_;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::release_signature() {
+  clear_has_signature();
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = signature_;
+  signature_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  delete signature_;
+  signature_ = signature;
+  if (signature) {
+    set_has_signature();
+  } else {
+    clear_has_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::has_image_headers() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_has_image_headers() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_has_image_headers() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_image_headers() {
+  if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+  clear_has_image_headers();
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientIncidentReport_IncidentData_BinaryIntegrityIncident::image_headers() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.image_headers)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return image_headers_ != NULL ? *image_headers_ : *default_instance().image_headers_;
+#else
+  return image_headers_ != NULL ? *image_headers_ : *default_instance_->image_headers_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::mutable_image_headers() {
+  set_has_image_headers();
+  if (image_headers_ == NULL) image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.image_headers)
+  return image_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BinaryIntegrityIncident::release_image_headers() {
+  clear_has_image_headers();
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = image_headers_;
+  image_headers_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  delete image_headers_;
+  image_headers_ = image_headers;
+  if (image_headers) {
+    set_has_image_headers();
+  } else {
+    clear_has_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::has_sec_error() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_has_sec_error() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_has_sec_error() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_sec_error() {
+  sec_error_ = 0;
+  clear_has_sec_error();
+}
+inline ::google::protobuf::int32 ClientIncidentReport_IncidentData_BinaryIntegrityIncident::sec_error() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BinaryIntegrityIncident.sec_error)
+  return sec_error_;
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::set_sec_error(::google::protobuf::int32 value) {
+  set_has_sec_error();
+  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::contained_file_size() const {
+  return contained_file_.size();
+}
+inline void ClientIncidentReport_IncidentData_BinaryIntegrityIncident::clear_contained_file() {
+  contained_file_.Clear();
+}
+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 contained_file_.Get(index);
+}
+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 ::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 contained_file_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_IncidentData_BlacklistLoadIncident
+
+// optional string path = 1;
+inline bool ClientIncidentReport_IncidentData_BlacklistLoadIncident::has_path() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_has_path() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::clear_has_path() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::clear_path() {
+  if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_->clear();
+  }
+  clear_has_path();
+}
+inline const ::std::string& ClientIncidentReport_IncidentData_BlacklistLoadIncident::path() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.path)
+  return *path_;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_path(const ::std::string& value) {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  path_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.path)
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_path(const char* value) {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  path_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.path)
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_path(const char* value, size_t size) {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  path_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.path)
+}
+inline ::std::string* ClientIncidentReport_IncidentData_BlacklistLoadIncident::mutable_path() {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.path)
+  return path_;
+}
+inline ::std::string* ClientIncidentReport_IncidentData_BlacklistLoadIncident::release_path() {
+  clear_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = path_;
+    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_allocated_path(::std::string* path) {
+  if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete path_;
+  }
+  if (path) {
+    set_has_path();
+    path_ = path;
+  } else {
+    clear_has_path();
+    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.path)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.Digests digest = 2;
+inline bool ClientIncidentReport_IncidentData_BlacklistLoadIncident::has_digest() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_has_digest() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::clear_has_digest() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::clear_digest() {
+  if (digest_ != NULL) digest_->::safe_browsing::ClientDownloadRequest_Digests::Clear();
+  clear_has_digest();
+}
+inline const ::safe_browsing::ClientDownloadRequest_Digests& ClientIncidentReport_IncidentData_BlacklistLoadIncident::digest() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.digest)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return digest_ != NULL ? *digest_ : *default_instance().digest_;
+#else
+  return digest_ != NULL ? *digest_ : *default_instance_->digest_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientIncidentReport_IncidentData_BlacklistLoadIncident::mutable_digest() {
+  set_has_digest();
+  if (digest_ == NULL) digest_ = new ::safe_browsing::ClientDownloadRequest_Digests;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.digest)
+  return digest_;
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientIncidentReport_IncidentData_BlacklistLoadIncident::release_digest() {
+  clear_has_digest();
+  ::safe_browsing::ClientDownloadRequest_Digests* temp = digest_;
+  digest_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_allocated_digest(::safe_browsing::ClientDownloadRequest_Digests* digest) {
+  delete digest_;
+  digest_ = digest;
+  if (digest) {
+    set_has_digest();
+  } else {
+    clear_has_digest();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.digest)
+}
+
+// optional string version = 3;
+inline bool ClientIncidentReport_IncidentData_BlacklistLoadIncident::has_version() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_has_version() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::clear_has_version() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::clear_version() {
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_->clear();
+  }
+  clear_has_version();
+}
+inline const ::std::string& ClientIncidentReport_IncidentData_BlacklistLoadIncident::version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.version)
+  return *version_;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_version(const ::std::string& value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.version)
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_version(const char* value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.version)
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_version(const char* value, size_t size) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.version)
+}
+inline ::std::string* ClientIncidentReport_IncidentData_BlacklistLoadIncident::mutable_version() {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.version)
+  return version_;
+}
+inline ::std::string* ClientIncidentReport_IncidentData_BlacklistLoadIncident::release_version() {
+  clear_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = version_;
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_allocated_version(::std::string* version) {
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete version_;
+  }
+  if (version) {
+    set_has_version();
+    version_ = version;
+  } else {
+    clear_has_version();
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.version)
+}
+
+// optional bool blacklist_initialized = 4;
+inline bool ClientIncidentReport_IncidentData_BlacklistLoadIncident::has_blacklist_initialized() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_has_blacklist_initialized() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::clear_has_blacklist_initialized() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::clear_blacklist_initialized() {
+  blacklist_initialized_ = false;
+  clear_has_blacklist_initialized();
+}
+inline bool ClientIncidentReport_IncidentData_BlacklistLoadIncident::blacklist_initialized() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.blacklist_initialized)
+  return blacklist_initialized_;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_blacklist_initialized(bool value) {
+  set_has_blacklist_initialized();
+  blacklist_initialized_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.blacklist_initialized)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;
+inline bool ClientIncidentReport_IncidentData_BlacklistLoadIncident::has_signature() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_has_signature() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::clear_has_signature() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::clear_signature() {
+  if (signature_ != NULL) signature_->::safe_browsing::ClientDownloadRequest_SignatureInfo::Clear();
+  clear_has_signature();
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientIncidentReport_IncidentData_BlacklistLoadIncident::signature() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.signature)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return signature_ != NULL ? *signature_ : *default_instance().signature_;
+#else
+  return signature_ != NULL ? *signature_ : *default_instance_->signature_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BlacklistLoadIncident::mutable_signature() {
+  set_has_signature();
+  if (signature_ == NULL) signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.signature)
+  return signature_;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_BlacklistLoadIncident::release_signature() {
+  clear_has_signature();
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = signature_;
+  signature_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  delete signature_;
+  signature_ = signature;
+  if (signature) {
+    set_has_signature();
+  } else {
+    clear_has_signature();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.signature)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 6;
+inline bool ClientIncidentReport_IncidentData_BlacklistLoadIncident::has_image_headers() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_has_image_headers() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::clear_has_image_headers() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::clear_image_headers() {
+  if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+  clear_has_image_headers();
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientIncidentReport_IncidentData_BlacklistLoadIncident::image_headers() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.image_headers)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return image_headers_ != NULL ? *image_headers_ : *default_instance().image_headers_;
+#else
+  return image_headers_ != NULL ? *image_headers_ : *default_instance_->image_headers_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BlacklistLoadIncident::mutable_image_headers() {
+  set_has_image_headers();
+  if (image_headers_ == NULL) image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.image_headers)
+  return image_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_BlacklistLoadIncident::release_image_headers() {
+  clear_has_image_headers();
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = image_headers_;
+  image_headers_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData_BlacklistLoadIncident::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  delete image_headers_;
+  image_headers_ = image_headers;
+  if (image_headers) {
+    set_has_image_headers();
+  } else {
+    clear_has_image_headers();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident.image_headers)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident
+
+// optional string variations_seed_signature = 1;
+inline bool ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::has_variations_seed_signature() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::set_has_variations_seed_signature() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::clear_has_variations_seed_signature() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::clear_variations_seed_signature() {
+  if (variations_seed_signature_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    variations_seed_signature_->clear();
+  }
+  clear_has_variations_seed_signature();
+}
+inline const ::std::string& ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::variations_seed_signature() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident.variations_seed_signature)
+  return *variations_seed_signature_;
+}
+inline void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::set_variations_seed_signature(const ::std::string& value) {
+  set_has_variations_seed_signature();
+  if (variations_seed_signature_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    variations_seed_signature_ = new ::std::string;
+  }
+  variations_seed_signature_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident.variations_seed_signature)
+}
+inline void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::set_variations_seed_signature(const char* value) {
+  set_has_variations_seed_signature();
+  if (variations_seed_signature_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    variations_seed_signature_ = new ::std::string;
+  }
+  variations_seed_signature_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident.variations_seed_signature)
+}
+inline void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::set_variations_seed_signature(const char* value, size_t size) {
+  set_has_variations_seed_signature();
+  if (variations_seed_signature_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    variations_seed_signature_ = new ::std::string;
+  }
+  variations_seed_signature_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident.variations_seed_signature)
+}
+inline ::std::string* ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::mutable_variations_seed_signature() {
+  set_has_variations_seed_signature();
+  if (variations_seed_signature_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    variations_seed_signature_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident.variations_seed_signature)
+  return variations_seed_signature_;
+}
+inline ::std::string* ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::release_variations_seed_signature() {
+  clear_has_variations_seed_signature();
+  if (variations_seed_signature_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = variations_seed_signature_;
+    variations_seed_signature_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::set_allocated_variations_seed_signature(::std::string* variations_seed_signature) {
+  if (variations_seed_signature_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete variations_seed_signature_;
+  }
+  if (variations_seed_signature) {
+    set_has_variations_seed_signature();
+    variations_seed_signature_ = variations_seed_signature;
+  } else {
+    clear_has_variations_seed_signature();
+    variations_seed_signature_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident.variations_seed_signature)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_IncidentData_ResourceRequestIncident
+
+// optional bytes digest = 1;
+inline bool ClientIncidentReport_IncidentData_ResourceRequestIncident::has_digest() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_has_digest() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::clear_has_digest() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::clear_digest() {
+  if (digest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    digest_->clear();
+  }
+  clear_has_digest();
+}
+inline const ::std::string& ClientIncidentReport_IncidentData_ResourceRequestIncident::digest() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest)
+  return *digest_;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_digest(const ::std::string& value) {
+  set_has_digest();
+  if (digest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    digest_ = new ::std::string;
+  }
+  digest_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest)
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_digest(const char* value) {
+  set_has_digest();
+  if (digest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    digest_ = new ::std::string;
+  }
+  digest_->assign(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) {
+  set_has_digest();
+  if (digest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    digest_ = new ::std::string;
+  }
+  digest_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest)
+}
+inline ::std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::mutable_digest() {
+  set_has_digest();
+  if (digest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    digest_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest)
+  return digest_;
+}
+inline ::std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::release_digest() {
+  clear_has_digest();
+  if (digest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = digest_;
+    digest_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_allocated_digest(::std::string* digest) {
+  if (digest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete digest_;
+  }
+  if (digest) {
+    set_has_digest();
+    digest_ = digest;
+  } else {
+    clear_has_digest();
+    digest_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.digest)
+}
+
+// optional string origin = 2;
+inline bool ClientIncidentReport_IncidentData_ResourceRequestIncident::has_origin() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_has_origin() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::clear_has_origin() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::clear_origin() {
+  if (origin_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    origin_->clear();
+  }
+  clear_has_origin();
+}
+inline const ::std::string& ClientIncidentReport_IncidentData_ResourceRequestIncident::origin() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin)
+  return *origin_;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_origin(const ::std::string& value) {
+  set_has_origin();
+  if (origin_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    origin_ = new ::std::string;
+  }
+  origin_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin)
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_origin(const char* value) {
+  set_has_origin();
+  if (origin_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    origin_ = new ::std::string;
+  }
+  origin_->assign(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) {
+  set_has_origin();
+  if (origin_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    origin_ = new ::std::string;
+  }
+  origin_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin)
+}
+inline ::std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::mutable_origin() {
+  set_has_origin();
+  if (origin_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    origin_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.origin)
+  return origin_;
+}
+inline ::std::string* ClientIncidentReport_IncidentData_ResourceRequestIncident::release_origin() {
+  clear_has_origin();
+  if (origin_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = origin_;
+    origin_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_allocated_origin(::std::string* origin) {
+  if (origin_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete origin_;
+  }
+  if (origin) {
+    set_has_origin();
+    origin_ = origin;
+  } else {
+    clear_has_origin();
+    origin_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::has_type() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_has_type() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::clear_has_type() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::clear_type() {
+  type_ = 0;
+  clear_has_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 static_cast< ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type >(type_);
+}
+inline void ClientIncidentReport_IncidentData_ResourceRequestIncident::set_type(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type value) {
+  assert(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident_Type_IsValid(value));
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident.type)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_IncidentData_SuspiciousModuleIncident
+
+// optional string path = 1;
+inline bool ClientIncidentReport_IncidentData_SuspiciousModuleIncident::has_path() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_has_path() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::clear_has_path() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::clear_path() {
+  if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_->clear();
+  }
+  clear_has_path();
+}
+inline const ::std::string& ClientIncidentReport_IncidentData_SuspiciousModuleIncident::path() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.path)
+  return *path_;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_path(const ::std::string& value) {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  path_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.path)
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_path(const char* value) {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  path_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.path)
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_path(const char* value, size_t size) {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  path_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.path)
+}
+inline ::std::string* ClientIncidentReport_IncidentData_SuspiciousModuleIncident::mutable_path() {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.path)
+  return path_;
+}
+inline ::std::string* ClientIncidentReport_IncidentData_SuspiciousModuleIncident::release_path() {
+  clear_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = path_;
+    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_allocated_path(::std::string* path) {
+  if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete path_;
+  }
+  if (path) {
+    set_has_path();
+    path_ = path;
+  } else {
+    clear_has_path();
+    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.path)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.Digests digest = 2;
+inline bool ClientIncidentReport_IncidentData_SuspiciousModuleIncident::has_digest() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_has_digest() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::clear_has_digest() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::clear_digest() {
+  if (digest_ != NULL) digest_->::safe_browsing::ClientDownloadRequest_Digests::Clear();
+  clear_has_digest();
+}
+inline const ::safe_browsing::ClientDownloadRequest_Digests& ClientIncidentReport_IncidentData_SuspiciousModuleIncident::digest() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.digest)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return digest_ != NULL ? *digest_ : *default_instance().digest_;
+#else
+  return digest_ != NULL ? *digest_ : *default_instance_->digest_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientIncidentReport_IncidentData_SuspiciousModuleIncident::mutable_digest() {
+  set_has_digest();
+  if (digest_ == NULL) digest_ = new ::safe_browsing::ClientDownloadRequest_Digests;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.digest)
+  return digest_;
+}
+inline ::safe_browsing::ClientDownloadRequest_Digests* ClientIncidentReport_IncidentData_SuspiciousModuleIncident::release_digest() {
+  clear_has_digest();
+  ::safe_browsing::ClientDownloadRequest_Digests* temp = digest_;
+  digest_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_allocated_digest(::safe_browsing::ClientDownloadRequest_Digests* digest) {
+  delete digest_;
+  digest_ = digest;
+  if (digest) {
+    set_has_digest();
+  } else {
+    clear_has_digest();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.digest)
+}
+
+// optional string version = 3;
+inline bool ClientIncidentReport_IncidentData_SuspiciousModuleIncident::has_version() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_has_version() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::clear_has_version() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::clear_version() {
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_->clear();
+  }
+  clear_has_version();
+}
+inline const ::std::string& ClientIncidentReport_IncidentData_SuspiciousModuleIncident::version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.version)
+  return *version_;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_version(const ::std::string& value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.version)
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_version(const char* value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.version)
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_version(const char* value, size_t size) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.version)
+}
+inline ::std::string* ClientIncidentReport_IncidentData_SuspiciousModuleIncident::mutable_version() {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.version)
+  return version_;
+}
+inline ::std::string* ClientIncidentReport_IncidentData_SuspiciousModuleIncident::release_version() {
+  clear_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = version_;
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_allocated_version(::std::string* version) {
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete version_;
+  }
+  if (version) {
+    set_has_version();
+    version_ = version;
+  } else {
+    clear_has_version();
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.version)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 4;
+inline bool ClientIncidentReport_IncidentData_SuspiciousModuleIncident::has_signature() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_has_signature() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::clear_has_signature() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::clear_signature() {
+  if (signature_ != NULL) signature_->::safe_browsing::ClientDownloadRequest_SignatureInfo::Clear();
+  clear_has_signature();
+}
+inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientIncidentReport_IncidentData_SuspiciousModuleIncident::signature() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.signature)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return signature_ != NULL ? *signature_ : *default_instance().signature_;
+#else
+  return signature_ != NULL ? *signature_ : *default_instance_->signature_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_SuspiciousModuleIncident::mutable_signature() {
+  set_has_signature();
+  if (signature_ == NULL) signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.signature)
+  return signature_;
+}
+inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientIncidentReport_IncidentData_SuspiciousModuleIncident::release_signature() {
+  clear_has_signature();
+  ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = signature_;
+  signature_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_allocated_signature(::safe_browsing::ClientDownloadRequest_SignatureInfo* signature) {
+  delete signature_;
+  signature_ = signature;
+  if (signature) {
+    set_has_signature();
+  } else {
+    clear_has_signature();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.signature)
+}
+
+// optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+inline bool ClientIncidentReport_IncidentData_SuspiciousModuleIncident::has_image_headers() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_has_image_headers() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::clear_has_image_headers() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::clear_image_headers() {
+  if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+  clear_has_image_headers();
+}
+inline const ::safe_browsing::ClientDownloadRequest_ImageHeaders& ClientIncidentReport_IncidentData_SuspiciousModuleIncident::image_headers() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.image_headers)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return image_headers_ != NULL ? *image_headers_ : *default_instance().image_headers_;
+#else
+  return image_headers_ != NULL ? *image_headers_ : *default_instance_->image_headers_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_SuspiciousModuleIncident::mutable_image_headers() {
+  set_has_image_headers();
+  if (image_headers_ == NULL) image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.image_headers)
+  return image_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_IncidentData_SuspiciousModuleIncident::release_image_headers() {
+  clear_has_image_headers();
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = image_headers_;
+  image_headers_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData_SuspiciousModuleIncident::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  delete image_headers_;
+  image_headers_ = image_headers;
+  if (image_headers) {
+    set_has_image_headers();
+  } else {
+    clear_has_image_headers();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident.image_headers)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_IncidentData
+
+// optional int64 incident_time_msec = 1;
+inline bool ClientIncidentReport_IncidentData::has_incident_time_msec() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_IncidentData::set_has_incident_time_msec() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData::clear_has_incident_time_msec() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_IncidentData::clear_incident_time_msec() {
+  incident_time_msec_ = GOOGLE_LONGLONG(0);
+  clear_has_incident_time_msec();
+}
+inline ::google::protobuf::int64 ClientIncidentReport_IncidentData::incident_time_msec() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.incident_time_msec)
+  return incident_time_msec_;
+}
+inline void ClientIncidentReport_IncidentData::set_incident_time_msec(::google::protobuf::int64 value) {
+  set_has_incident_time_msec();
+  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::has_tracked_preference() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_IncidentData::set_has_tracked_preference() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData::clear_has_tracked_preference() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_IncidentData::clear_tracked_preference() {
+  if (tracked_preference_ != NULL) tracked_preference_->::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident::Clear();
+  clear_has_tracked_preference();
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident& ClientIncidentReport_IncidentData::tracked_preference() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.tracked_preference)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return tracked_preference_ != NULL ? *tracked_preference_ : *default_instance().tracked_preference_;
+#else
+  return tracked_preference_ != NULL ? *tracked_preference_ : *default_instance_->tracked_preference_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* ClientIncidentReport_IncidentData::mutable_tracked_preference() {
+  set_has_tracked_preference();
+  if (tracked_preference_ == NULL) tracked_preference_ = new ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.tracked_preference)
+  return tracked_preference_;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* ClientIncidentReport_IncidentData::release_tracked_preference() {
+  clear_has_tracked_preference();
+  ::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* temp = tracked_preference_;
+  tracked_preference_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData::set_allocated_tracked_preference(::safe_browsing::ClientIncidentReport_IncidentData_TrackedPreferenceIncident* tracked_preference) {
+  delete tracked_preference_;
+  tracked_preference_ = tracked_preference;
+  if (tracked_preference) {
+    set_has_tracked_preference();
+  } else {
+    clear_has_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::has_binary_integrity() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_IncidentData::set_has_binary_integrity() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_IncidentData::clear_has_binary_integrity() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_IncidentData::clear_binary_integrity() {
+  if (binary_integrity_ != NULL) binary_integrity_->::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident::Clear();
+  clear_has_binary_integrity();
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident& ClientIncidentReport_IncidentData::binary_integrity() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.binary_integrity)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return binary_integrity_ != NULL ? *binary_integrity_ : *default_instance().binary_integrity_;
+#else
+  return binary_integrity_ != NULL ? *binary_integrity_ : *default_instance_->binary_integrity_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* ClientIncidentReport_IncidentData::mutable_binary_integrity() {
+  set_has_binary_integrity();
+  if (binary_integrity_ == NULL) binary_integrity_ = new ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.binary_integrity)
+  return binary_integrity_;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* ClientIncidentReport_IncidentData::release_binary_integrity() {
+  clear_has_binary_integrity();
+  ::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* temp = binary_integrity_;
+  binary_integrity_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData::set_allocated_binary_integrity(::safe_browsing::ClientIncidentReport_IncidentData_BinaryIntegrityIncident* binary_integrity) {
+  delete binary_integrity_;
+  binary_integrity_ = binary_integrity;
+  if (binary_integrity) {
+    set_has_binary_integrity();
+  } else {
+    clear_has_binary_integrity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.binary_integrity)
+}
+
+// optional .safe_browsing.ClientIncidentReport.IncidentData.BlacklistLoadIncident blacklist_load = 4;
+inline bool ClientIncidentReport_IncidentData::has_blacklist_load() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientIncidentReport_IncidentData::set_has_blacklist_load() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientIncidentReport_IncidentData::clear_has_blacklist_load() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientIncidentReport_IncidentData::clear_blacklist_load() {
+  if (blacklist_load_ != NULL) blacklist_load_->::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident::Clear();
+  clear_has_blacklist_load();
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident& ClientIncidentReport_IncidentData::blacklist_load() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.blacklist_load)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return blacklist_load_ != NULL ? *blacklist_load_ : *default_instance().blacklist_load_;
+#else
+  return blacklist_load_ != NULL ? *blacklist_load_ : *default_instance_->blacklist_load_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident* ClientIncidentReport_IncidentData::mutable_blacklist_load() {
+  set_has_blacklist_load();
+  if (blacklist_load_ == NULL) blacklist_load_ = new ::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.blacklist_load)
+  return blacklist_load_;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident* ClientIncidentReport_IncidentData::release_blacklist_load() {
+  clear_has_blacklist_load();
+  ::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident* temp = blacklist_load_;
+  blacklist_load_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData::set_allocated_blacklist_load(::safe_browsing::ClientIncidentReport_IncidentData_BlacklistLoadIncident* blacklist_load) {
+  delete blacklist_load_;
+  blacklist_load_ = blacklist_load;
+  if (blacklist_load) {
+    set_has_blacklist_load();
+  } else {
+    clear_has_blacklist_load();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.blacklist_load)
+}
+
+// optional .safe_browsing.ClientIncidentReport.IncidentData.VariationsSeedSignatureIncident variations_seed_signature = 6;
+inline bool ClientIncidentReport_IncidentData::has_variations_seed_signature() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientIncidentReport_IncidentData::set_has_variations_seed_signature() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientIncidentReport_IncidentData::clear_has_variations_seed_signature() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientIncidentReport_IncidentData::clear_variations_seed_signature() {
+  if (variations_seed_signature_ != NULL) variations_seed_signature_->::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident::Clear();
+  clear_has_variations_seed_signature();
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident& ClientIncidentReport_IncidentData::variations_seed_signature() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.variations_seed_signature)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return variations_seed_signature_ != NULL ? *variations_seed_signature_ : *default_instance().variations_seed_signature_;
+#else
+  return variations_seed_signature_ != NULL ? *variations_seed_signature_ : *default_instance_->variations_seed_signature_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* ClientIncidentReport_IncidentData::mutable_variations_seed_signature() {
+  set_has_variations_seed_signature();
+  if (variations_seed_signature_ == NULL) variations_seed_signature_ = new ::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.variations_seed_signature)
+  return variations_seed_signature_;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* ClientIncidentReport_IncidentData::release_variations_seed_signature() {
+  clear_has_variations_seed_signature();
+  ::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* temp = variations_seed_signature_;
+  variations_seed_signature_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData::set_allocated_variations_seed_signature(::safe_browsing::ClientIncidentReport_IncidentData_VariationsSeedSignatureIncident* variations_seed_signature) {
+  delete variations_seed_signature_;
+  variations_seed_signature_ = variations_seed_signature;
+  if (variations_seed_signature) {
+    set_has_variations_seed_signature();
+  } else {
+    clear_has_variations_seed_signature();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.variations_seed_signature)
+}
+
+// optional .safe_browsing.ClientIncidentReport.IncidentData.ResourceRequestIncident resource_request = 7;
+inline bool ClientIncidentReport_IncidentData::has_resource_request() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClientIncidentReport_IncidentData::set_has_resource_request() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClientIncidentReport_IncidentData::clear_has_resource_request() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClientIncidentReport_IncidentData::clear_resource_request() {
+  if (resource_request_ != NULL) resource_request_->::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident::Clear();
+  clear_has_resource_request();
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident& ClientIncidentReport_IncidentData::resource_request() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.resource_request)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return resource_request_ != NULL ? *resource_request_ : *default_instance().resource_request_;
+#else
+  return resource_request_ != NULL ? *resource_request_ : *default_instance_->resource_request_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* ClientIncidentReport_IncidentData::mutable_resource_request() {
+  set_has_resource_request();
+  if (resource_request_ == NULL) resource_request_ = new ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.resource_request)
+  return resource_request_;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* ClientIncidentReport_IncidentData::release_resource_request() {
+  clear_has_resource_request();
+  ::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* temp = resource_request_;
+  resource_request_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData::set_allocated_resource_request(::safe_browsing::ClientIncidentReport_IncidentData_ResourceRequestIncident* resource_request) {
+  delete resource_request_;
+  resource_request_ = resource_request;
+  if (resource_request) {
+    set_has_resource_request();
+  } else {
+    clear_has_resource_request();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.resource_request)
+}
+
+// optional .safe_browsing.ClientIncidentReport.IncidentData.SuspiciousModuleIncident suspicious_module = 8;
+inline bool ClientIncidentReport_IncidentData::has_suspicious_module() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClientIncidentReport_IncidentData::set_has_suspicious_module() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClientIncidentReport_IncidentData::clear_has_suspicious_module() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClientIncidentReport_IncidentData::clear_suspicious_module() {
+  if (suspicious_module_ != NULL) suspicious_module_->::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident::Clear();
+  clear_has_suspicious_module();
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident& ClientIncidentReport_IncidentData::suspicious_module() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.IncidentData.suspicious_module)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return suspicious_module_ != NULL ? *suspicious_module_ : *default_instance().suspicious_module_;
+#else
+  return suspicious_module_ != NULL ? *suspicious_module_ : *default_instance_->suspicious_module_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident* ClientIncidentReport_IncidentData::mutable_suspicious_module() {
+  set_has_suspicious_module();
+  if (suspicious_module_ == NULL) suspicious_module_ = new ::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.IncidentData.suspicious_module)
+  return suspicious_module_;
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident* ClientIncidentReport_IncidentData::release_suspicious_module() {
+  clear_has_suspicious_module();
+  ::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident* temp = suspicious_module_;
+  suspicious_module_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_IncidentData::set_allocated_suspicious_module(::safe_browsing::ClientIncidentReport_IncidentData_SuspiciousModuleIncident* suspicious_module) {
+  delete suspicious_module_;
+  suspicious_module_ = suspicious_module;
+  if (suspicious_module) {
+    set_has_suspicious_module();
+  } else {
+    clear_has_suspicious_module();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.IncidentData.suspicious_module)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_DownloadDetails
+
+// optional bytes token = 1;
+inline bool ClientIncidentReport_DownloadDetails::has_token() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_DownloadDetails::set_has_token() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_DownloadDetails::clear_has_token() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_DownloadDetails::clear_token() {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_->clear();
+  }
+  clear_has_token();
+}
+inline const ::std::string& ClientIncidentReport_DownloadDetails::token() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.DownloadDetails.token)
+  return *token_;
+}
+inline void ClientIncidentReport_DownloadDetails::set_token(const ::std::string& value) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.DownloadDetails.token)
+}
+inline void ClientIncidentReport_DownloadDetails::set_token(const char* value) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.DownloadDetails.token)
+}
+inline void ClientIncidentReport_DownloadDetails::set_token(const void* value, size_t size) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.DownloadDetails.token)
+}
+inline ::std::string* ClientIncidentReport_DownloadDetails::mutable_token() {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.DownloadDetails.token)
+  return token_;
+}
+inline ::std::string* ClientIncidentReport_DownloadDetails::release_token() {
+  clear_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = token_;
+    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_DownloadDetails::set_allocated_token(::std::string* token) {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete token_;
+  }
+  if (token) {
+    set_has_token();
+    token_ = token;
+  } else {
+    clear_has_token();
+    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.DownloadDetails.token)
+}
+
+// optional .safe_browsing.ClientDownloadRequest download = 2;
+inline bool ClientIncidentReport_DownloadDetails::has_download() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_DownloadDetails::set_has_download() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_DownloadDetails::clear_has_download() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_DownloadDetails::clear_download() {
+  if (download_ != NULL) download_->::safe_browsing::ClientDownloadRequest::Clear();
+  clear_has_download();
+}
+inline const ::safe_browsing::ClientDownloadRequest& ClientIncidentReport_DownloadDetails::download() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.DownloadDetails.download)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return download_ != NULL ? *download_ : *default_instance().download_;
+#else
+  return download_ != NULL ? *download_ : *default_instance_->download_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest* ClientIncidentReport_DownloadDetails::mutable_download() {
+  set_has_download();
+  if (download_ == NULL) download_ = new ::safe_browsing::ClientDownloadRequest;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.DownloadDetails.download)
+  return download_;
+}
+inline ::safe_browsing::ClientDownloadRequest* ClientIncidentReport_DownloadDetails::release_download() {
+  clear_has_download();
+  ::safe_browsing::ClientDownloadRequest* temp = download_;
+  download_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_DownloadDetails::set_allocated_download(::safe_browsing::ClientDownloadRequest* download) {
+  delete download_;
+  download_ = download;
+  if (download) {
+    set_has_download();
+  } else {
+    clear_has_download();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.DownloadDetails.download)
+}
+
+// optional int64 download_time_msec = 3;
+inline bool ClientIncidentReport_DownloadDetails::has_download_time_msec() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_DownloadDetails::set_has_download_time_msec() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_DownloadDetails::clear_has_download_time_msec() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_DownloadDetails::clear_download_time_msec() {
+  download_time_msec_ = GOOGLE_LONGLONG(0);
+  clear_has_download_time_msec();
+}
+inline ::google::protobuf::int64 ClientIncidentReport_DownloadDetails::download_time_msec() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.DownloadDetails.download_time_msec)
+  return download_time_msec_;
+}
+inline void ClientIncidentReport_DownloadDetails::set_download_time_msec(::google::protobuf::int64 value) {
+  set_has_download_time_msec();
+  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::has_open_time_msec() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientIncidentReport_DownloadDetails::set_has_open_time_msec() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientIncidentReport_DownloadDetails::clear_has_open_time_msec() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientIncidentReport_DownloadDetails::clear_open_time_msec() {
+  open_time_msec_ = GOOGLE_LONGLONG(0);
+  clear_has_open_time_msec();
+}
+inline ::google::protobuf::int64 ClientIncidentReport_DownloadDetails::open_time_msec() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.DownloadDetails.open_time_msec)
+  return open_time_msec_;
+}
+inline void ClientIncidentReport_DownloadDetails::set_open_time_msec(::google::protobuf::int64 value) {
+  set_has_open_time_msec();
+  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::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& ClientIncidentReport_EnvironmentData_OS_RegistryValue::name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name)
+  return *name_;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name)
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(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) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(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::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name)
+  return name_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_OS_RegistryValue::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.name)
+}
+
+// optional uint32 type = 2;
+inline bool ClientIncidentReport_EnvironmentData_OS_RegistryValue::has_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_has_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::clear_has_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::clear_type() {
+  type_ = 0u;
+  clear_has_type();
+}
+inline ::google::protobuf::uint32 ClientIncidentReport_EnvironmentData_OS_RegistryValue::type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.type)
+  return type_;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_type(::google::protobuf::uint32 value) {
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.type)
+}
+
+// optional bytes data = 3;
+inline bool ClientIncidentReport_EnvironmentData_OS_RegistryValue::has_data() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_has_data() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::clear_has_data() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::clear_data() {
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_->clear();
+  }
+  clear_has_data();
+}
+inline const ::std::string& ClientIncidentReport_EnvironmentData_OS_RegistryValue::data() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.data)
+  return *data_;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_data(const ::std::string& value) {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_ = new ::std::string;
+  }
+  data_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.data)
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_data(const char* value) {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_ = new ::std::string;
+  }
+  data_->assign(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) {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_ = new ::std::string;
+  }
+  data_->assign(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::mutable_data() {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryValue.data)
+  return data_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_OS_RegistryValue::release_data() {
+  clear_has_data();
+  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = data_;
+    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryValue::set_allocated_data(::std::string* data) {
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete data_;
+  }
+  if (data) {
+    set_has_data();
+    data_ = data;
+  } else {
+    clear_has_data();
+    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& ClientIncidentReport_EnvironmentData_OS_RegistryKey::name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.name)
+  return *name_;
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.name)
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(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) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(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::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey.name)
+  return name_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_OS_RegistryKey::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::value_size() const {
+  return value_.size();
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::clear_value() {
+  value_.Clear();
+}
+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 value_.Get(index);
+}
+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 ::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 value_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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_;
+}
+
+// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.OS.RegistryKey key = 3;
+inline int ClientIncidentReport_EnvironmentData_OS_RegistryKey::key_size() const {
+  return key_.size();
+}
+inline void ClientIncidentReport_EnvironmentData_OS_RegistryKey::clear_key() {
+  key_.Clear();
+}
+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 key_.Get(index);
+}
+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 ::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 key_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData_OS
+
+// optional string os_name = 1;
+inline bool ClientIncidentReport_EnvironmentData_OS::has_os_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::set_has_os_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::clear_has_os_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::clear_os_name() {
+  if (os_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    os_name_->clear();
+  }
+  clear_has_os_name();
+}
+inline const ::std::string& ClientIncidentReport_EnvironmentData_OS::os_name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name)
+  return *os_name_;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::set_os_name(const ::std::string& value) {
+  set_has_os_name();
+  if (os_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    os_name_ = new ::std::string;
+  }
+  os_name_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name)
+}
+inline void ClientIncidentReport_EnvironmentData_OS::set_os_name(const char* value) {
+  set_has_os_name();
+  if (os_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    os_name_ = new ::std::string;
+  }
+  os_name_->assign(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) {
+  set_has_os_name();
+  if (os_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    os_name_ = new ::std::string;
+  }
+  os_name_->assign(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::mutable_os_name() {
+  set_has_os_name();
+  if (os_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    os_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name)
+  return os_name_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_OS::release_os_name() {
+  clear_has_os_name();
+  if (os_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = os_name_;
+    os_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_OS::set_allocated_os_name(::std::string* os_name) {
+  if (os_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete os_name_;
+  }
+  if (os_name) {
+    set_has_os_name();
+    os_name_ = os_name;
+  } else {
+    clear_has_os_name();
+    os_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_name)
+}
+
+// optional string os_version = 2;
+inline bool ClientIncidentReport_EnvironmentData_OS::has_os_version() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::set_has_os_version() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::clear_has_os_version() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::clear_os_version() {
+  if (os_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    os_version_->clear();
+  }
+  clear_has_os_version();
+}
+inline const ::std::string& ClientIncidentReport_EnvironmentData_OS::os_version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_version)
+  return *os_version_;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::set_os_version(const ::std::string& value) {
+  set_has_os_version();
+  if (os_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    os_version_ = new ::std::string;
+  }
+  os_version_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_version)
+}
+inline void ClientIncidentReport_EnvironmentData_OS::set_os_version(const char* value) {
+  set_has_os_version();
+  if (os_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    os_version_ = new ::std::string;
+  }
+  os_version_->assign(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) {
+  set_has_os_version();
+  if (os_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    os_version_ = new ::std::string;
+  }
+  os_version_->assign(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::mutable_os_version() {
+  set_has_os_version();
+  if (os_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    os_version_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.OS.os_version)
+  return os_version_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_OS::release_os_version() {
+  clear_has_os_version();
+  if (os_version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = os_version_;
+    os_version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_OS::set_allocated_os_version(::std::string* os_version) {
+  if (os_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete os_version_;
+  }
+  if (os_version) {
+    set_has_os_version();
+    os_version_ = os_version;
+  } else {
+    clear_has_os_version();
+    os_version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::registry_key_size() const {
+  return registry_key_.size();
+}
+inline void ClientIncidentReport_EnvironmentData_OS::clear_registry_key() {
+  registry_key_.Clear();
+}
+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 registry_key_.Get(index);
+}
+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 ::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 registry_key_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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 &registry_key_;
+}
+
+// optional bool is_enrolled_to_domain = 4;
+inline bool ClientIncidentReport_EnvironmentData_OS::has_is_enrolled_to_domain() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::set_has_is_enrolled_to_domain() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::clear_has_is_enrolled_to_domain() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::clear_is_enrolled_to_domain() {
+  is_enrolled_to_domain_ = false;
+  clear_has_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 is_enrolled_to_domain_;
+}
+inline void ClientIncidentReport_EnvironmentData_OS::set_is_enrolled_to_domain(bool value) {
+  set_has_is_enrolled_to_domain();
+  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::has_cpu_architecture() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::set_has_cpu_architecture() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::clear_has_cpu_architecture() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::clear_cpu_architecture() {
+  if (cpu_architecture_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    cpu_architecture_->clear();
+  }
+  clear_has_cpu_architecture();
+}
+inline const ::std::string& ClientIncidentReport_EnvironmentData_Machine::cpu_architecture() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture)
+  return *cpu_architecture_;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::set_cpu_architecture(const ::std::string& value) {
+  set_has_cpu_architecture();
+  if (cpu_architecture_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    cpu_architecture_ = new ::std::string;
+  }
+  cpu_architecture_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture)
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::set_cpu_architecture(const char* value) {
+  set_has_cpu_architecture();
+  if (cpu_architecture_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    cpu_architecture_ = new ::std::string;
+  }
+  cpu_architecture_->assign(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) {
+  set_has_cpu_architecture();
+  if (cpu_architecture_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    cpu_architecture_ = new ::std::string;
+  }
+  cpu_architecture_->assign(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::mutable_cpu_architecture() {
+  set_has_cpu_architecture();
+  if (cpu_architecture_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    cpu_architecture_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture)
+  return cpu_architecture_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_Machine::release_cpu_architecture() {
+  clear_has_cpu_architecture();
+  if (cpu_architecture_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = cpu_architecture_;
+    cpu_architecture_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::set_allocated_cpu_architecture(::std::string* cpu_architecture) {
+  if (cpu_architecture_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete cpu_architecture_;
+  }
+  if (cpu_architecture) {
+    set_has_cpu_architecture();
+    cpu_architecture_ = cpu_architecture;
+  } else {
+    clear_has_cpu_architecture();
+    cpu_architecture_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_architecture)
+}
+
+// optional string cpu_vendor = 2;
+inline bool ClientIncidentReport_EnvironmentData_Machine::has_cpu_vendor() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::set_has_cpu_vendor() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::clear_has_cpu_vendor() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::clear_cpu_vendor() {
+  if (cpu_vendor_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    cpu_vendor_->clear();
+  }
+  clear_has_cpu_vendor();
+}
+inline const ::std::string& ClientIncidentReport_EnvironmentData_Machine::cpu_vendor() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor)
+  return *cpu_vendor_;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::set_cpu_vendor(const ::std::string& value) {
+  set_has_cpu_vendor();
+  if (cpu_vendor_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    cpu_vendor_ = new ::std::string;
+  }
+  cpu_vendor_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor)
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::set_cpu_vendor(const char* value) {
+  set_has_cpu_vendor();
+  if (cpu_vendor_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    cpu_vendor_ = new ::std::string;
+  }
+  cpu_vendor_->assign(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) {
+  set_has_cpu_vendor();
+  if (cpu_vendor_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    cpu_vendor_ = new ::std::string;
+  }
+  cpu_vendor_->assign(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::mutable_cpu_vendor() {
+  set_has_cpu_vendor();
+  if (cpu_vendor_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    cpu_vendor_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor)
+  return cpu_vendor_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_Machine::release_cpu_vendor() {
+  clear_has_cpu_vendor();
+  if (cpu_vendor_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = cpu_vendor_;
+    cpu_vendor_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::set_allocated_cpu_vendor(::std::string* cpu_vendor) {
+  if (cpu_vendor_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete cpu_vendor_;
+  }
+  if (cpu_vendor) {
+    set_has_cpu_vendor();
+    cpu_vendor_ = cpu_vendor;
+  } else {
+    clear_has_cpu_vendor();
+    cpu_vendor_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpu_vendor)
+}
+
+// optional uint32 cpuid = 3;
+inline bool ClientIncidentReport_EnvironmentData_Machine::has_cpuid() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::set_has_cpuid() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::clear_has_cpuid() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::clear_cpuid() {
+  cpuid_ = 0u;
+  clear_has_cpuid();
+}
+inline ::google::protobuf::uint32 ClientIncidentReport_EnvironmentData_Machine::cpuid() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Machine.cpuid)
+  return cpuid_;
+}
+inline void ClientIncidentReport_EnvironmentData_Machine::set_cpuid(::google::protobuf::uint32 value) {
+  set_has_cpuid();
+  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::has_function() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_has_function() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::clear_has_function() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::clear_function() {
+  if (function_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    function_->clear();
+  }
+  clear_has_function();
+}
+inline const ::std::string& ClientIncidentReport_EnvironmentData_Process_Patch::function() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function)
+  return *function_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_function(const ::std::string& value) {
+  set_has_function();
+  if (function_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    function_ = new ::std::string;
+  }
+  function_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function)
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_function(const char* value) {
+  set_has_function();
+  if (function_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    function_ = new ::std::string;
+  }
+  function_->assign(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) {
+  set_has_function();
+  if (function_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    function_ = new ::std::string;
+  }
+  function_->assign(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::mutable_function() {
+  set_has_function();
+  if (function_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    function_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function)
+  return function_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_Process_Patch::release_function() {
+  clear_has_function();
+  if (function_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = function_;
+    function_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_allocated_function(::std::string* function) {
+  if (function_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete function_;
+  }
+  if (function) {
+    set_has_function();
+    function_ = function;
+  } else {
+    clear_has_function();
+    function_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.function)
+}
+
+// optional string target_dll = 2;
+inline bool ClientIncidentReport_EnvironmentData_Process_Patch::has_target_dll() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_has_target_dll() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::clear_has_target_dll() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::clear_target_dll() {
+  if (target_dll_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_dll_->clear();
+  }
+  clear_has_target_dll();
+}
+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 *target_dll_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_target_dll(const ::std::string& value) {
+  set_has_target_dll();
+  if (target_dll_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_dll_ = new ::std::string;
+  }
+  target_dll_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.target_dll)
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_target_dll(const char* value) {
+  set_has_target_dll();
+  if (target_dll_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_dll_ = new ::std::string;
+  }
+  target_dll_->assign(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) {
+  set_has_target_dll();
+  if (target_dll_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_dll_ = new ::std::string;
+  }
+  target_dll_->assign(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::mutable_target_dll() {
+  set_has_target_dll();
+  if (target_dll_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_dll_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Patch.target_dll)
+  return target_dll_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_Process_Patch::release_target_dll() {
+  clear_has_target_dll();
+  if (target_dll_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = target_dll_;
+    target_dll_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Patch::set_allocated_target_dll(::std::string* target_dll) {
+  if (target_dll_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete target_dll_;
+  }
+  if (target_dll) {
+    set_has_target_dll();
+    target_dll_ = target_dll;
+  } else {
+    clear_has_target_dll();
+    target_dll_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::has_path() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_has_path() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_has_path() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_path() {
+  if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_->clear();
+  }
+  clear_has_path();
+}
+inline const ::std::string& ClientIncidentReport_EnvironmentData_Process_Dll::path() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path)
+  return *path_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_path(const ::std::string& value) {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  path_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path)
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_path(const char* value) {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  path_->assign(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) {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  path_->assign(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::mutable_path() {
+  set_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    path_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path)
+  return path_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_Process_Dll::release_path() {
+  clear_has_path();
+  if (path_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = path_;
+    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_allocated_path(::std::string* path) {
+  if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete path_;
+  }
+  if (path) {
+    set_has_path();
+    path_ = path;
+  } else {
+    clear_has_path();
+    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.path)
+}
+
+// optional uint64 base_address = 2;
+inline bool ClientIncidentReport_EnvironmentData_Process_Dll::has_base_address() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_has_base_address() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_has_base_address() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_base_address() {
+  base_address_ = GOOGLE_ULONGLONG(0);
+  clear_has_base_address();
+}
+inline ::google::protobuf::uint64 ClientIncidentReport_EnvironmentData_Process_Dll::base_address() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.base_address)
+  return base_address_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_base_address(::google::protobuf::uint64 value) {
+  set_has_base_address();
+  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::has_length() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_has_length() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_has_length() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_length() {
+  length_ = 0u;
+  clear_has_length();
+}
+inline ::google::protobuf::uint32 ClientIncidentReport_EnvironmentData_Process_Dll::length() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.length)
+  return length_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_length(::google::protobuf::uint32 value) {
+  set_has_length();
+  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::feature_size() const {
+  return feature_.size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_feature() {
+  feature_.Clear();
+}
+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 static_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature >(feature_.Get(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::add_feature(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature value) {
+  assert(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll_Feature_IsValid(value));
+  feature_.Add(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.feature)
+}
+inline const ::google::protobuf::RepeatedField<int>&
+ClientIncidentReport_EnvironmentData_Process_Dll::feature() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.feature)
+  return feature_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+ClientIncidentReport_EnvironmentData_Process_Dll::mutable_feature() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.feature)
+  return &feature_;
+}
+
+// optional .safe_browsing.ClientDownloadRequest.ImageHeaders image_headers = 5;
+inline bool ClientIncidentReport_EnvironmentData_Process_Dll::has_image_headers() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_has_image_headers() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_has_image_headers() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::clear_image_headers() {
+  if (image_headers_ != NULL) image_headers_->::safe_browsing::ClientDownloadRequest_ImageHeaders::Clear();
+  clear_has_image_headers();
+}
+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)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return image_headers_ != NULL ? *image_headers_ : *default_instance().image_headers_;
+#else
+  return image_headers_ != NULL ? *image_headers_ : *default_instance_->image_headers_;
+#endif
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_EnvironmentData_Process_Dll::mutable_image_headers() {
+  set_has_image_headers();
+  if (image_headers_ == NULL) image_headers_ = new ::safe_browsing::ClientDownloadRequest_ImageHeaders;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll.image_headers)
+  return image_headers_;
+}
+inline ::safe_browsing::ClientDownloadRequest_ImageHeaders* ClientIncidentReport_EnvironmentData_Process_Dll::release_image_headers() {
+  clear_has_image_headers();
+  ::safe_browsing::ClientDownloadRequest_ImageHeaders* temp = image_headers_;
+  image_headers_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_Dll::set_allocated_image_headers(::safe_browsing::ClientDownloadRequest_ImageHeaders* image_headers) {
+  delete image_headers_;
+  image_headers_ = image_headers;
+  if (image_headers) {
+    set_has_image_headers();
+  } else {
+    clear_has_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::has_file_offset() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_has_file_offset() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::clear_has_file_offset() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::clear_file_offset() {
+  file_offset_ = 0u;
+  clear_has_file_offset();
+}
+inline ::google::protobuf::uint32 ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::file_offset() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.file_offset)
+  return file_offset_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_file_offset(::google::protobuf::uint32 value) {
+  set_has_file_offset();
+  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::has_byte_count() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_has_byte_count() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::clear_has_byte_count() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::clear_byte_count() {
+  byte_count_ = 0;
+  clear_has_byte_count();
+}
+inline ::google::protobuf::int32 ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::byte_count() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.byte_count)
+  return byte_count_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_byte_count(::google::protobuf::int32 value) {
+  set_has_byte_count();
+  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::has_modified_bytes() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_has_modified_bytes() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::clear_has_modified_bytes() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::clear_modified_bytes() {
+  if (modified_bytes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    modified_bytes_->clear();
+  }
+  clear_has_modified_bytes();
+}
+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 *modified_bytes_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_modified_bytes(const ::std::string& value) {
+  set_has_modified_bytes();
+  if (modified_bytes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    modified_bytes_ = new ::std::string;
+  }
+  modified_bytes_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.modified_bytes)
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_modified_bytes(const char* value) {
+  set_has_modified_bytes();
+  if (modified_bytes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    modified_bytes_ = new ::std::string;
+  }
+  modified_bytes_->assign(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) {
+  set_has_modified_bytes();
+  if (modified_bytes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    modified_bytes_ = new ::std::string;
+  }
+  modified_bytes_->assign(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::mutable_modified_bytes() {
+  set_has_modified_bytes();
+  if (modified_bytes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    modified_bytes_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.modified_bytes)
+  return modified_bytes_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::release_modified_bytes() {
+  clear_has_modified_bytes();
+  if (modified_bytes_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = modified_bytes_;
+    modified_bytes_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_allocated_modified_bytes(::std::string* modified_bytes) {
+  if (modified_bytes_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete modified_bytes_;
+  }
+  if (modified_bytes) {
+    set_has_modified_bytes();
+    modified_bytes_ = modified_bytes;
+  } else {
+    clear_has_modified_bytes();
+    modified_bytes_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::has_export_name() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_has_export_name() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::clear_has_export_name() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::clear_export_name() {
+  if (export_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    export_name_->clear();
+  }
+  clear_has_export_name();
+}
+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 *export_name_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_export_name(const ::std::string& value) {
+  set_has_export_name();
+  if (export_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    export_name_ = new ::std::string;
+  }
+  export_name_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.export_name)
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_export_name(const char* value) {
+  set_has_export_name();
+  if (export_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    export_name_ = new ::std::string;
+  }
+  export_name_->assign(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) {
+  set_has_export_name();
+  if (export_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    export_name_ = new ::std::string;
+  }
+  export_name_->assign(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::mutable_export_name() {
+  set_has_export_name();
+  if (export_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    export_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.Modification.export_name)
+  return export_name_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::release_export_name() {
+  clear_has_export_name();
+  if (export_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = export_name_;
+    export_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState_Modification::set_allocated_export_name(::std::string* export_name) {
+  if (export_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete export_name_;
+  }
+  if (export_name) {
+    set_has_export_name();
+    export_name_ = export_name;
+  } else {
+    clear_has_export_name();
+    export_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& ClientIncidentReport_EnvironmentData_Process_ModuleState::name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.name)
+  return *name_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.name)
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(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) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(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::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.ModuleState.name)
+  return name_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_Process_ModuleState::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::has_modified_state() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_has_modified_state() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::clear_has_modified_state() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::clear_modified_state() {
+  modified_state_ = 0;
+  clear_has_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 static_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState >(modified_state_);
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::set_modified_state(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState value) {
+  assert(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_ModuleState_ModifiedState_IsValid(value));
+  set_has_modified_state();
+  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::obsolete_modified_export_size() const {
+  return obsolete_modified_export_.size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::clear_obsolete_modified_export() {
+  obsolete_modified_export_.Clear();
+}
+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 obsolete_modified_export_.Get(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, const char* value) {
+  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::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(const char* value) {
+  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 ::google::protobuf::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 ::google::protobuf::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::modification_size() const {
+  return modification_.size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process_ModuleState::clear_modification() {
+  modification_.Clear();
+}
+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 modification_.Get(index);
+}
+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 ::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 modification_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData_Process
+
+// optional string version = 1;
+inline bool ClientIncidentReport_EnvironmentData_Process::has_version() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_has_version() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_has_version() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_version() {
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_->clear();
+  }
+  clear_has_version();
+}
+inline const ::std::string& ClientIncidentReport_EnvironmentData_Process::version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version)
+  return *version_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_version(const ::std::string& value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version)
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_version(const char* value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(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) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version)
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_Process::mutable_version() {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version)
+  return version_;
+}
+inline ::std::string* ClientIncidentReport_EnvironmentData_Process::release_version() {
+  clear_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = version_;
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_allocated_version(::std::string* version) {
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete version_;
+  }
+  if (version) {
+    set_has_version();
+    version_ = version;
+  } else {
+    clear_has_version();
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.Process.version)
+}
+
+// repeated string OBSOLETE_dlls = 2;
+inline int ClientIncidentReport_EnvironmentData_Process::obsolete_dlls_size() const {
+  return obsolete_dlls_.size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_obsolete_dlls() {
+  obsolete_dlls_.Clear();
+}
+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 obsolete_dlls_.Get(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, const char* value) {
+  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::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(const char* value) {
+  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 ::google::protobuf::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 ::google::protobuf::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::patches_size() const {
+  return patches_.size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_patches() {
+  patches_.Clear();
+}
+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 patches_.Get(index);
+}
+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 ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Patch* ClientIncidentReport_EnvironmentData_Process::add_patches() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.patches)
+  return patches_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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_;
+}
+
+// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.NetworkProvider network_providers = 4;
+inline int ClientIncidentReport_EnvironmentData_Process::network_providers_size() const {
+  return network_providers_.size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_network_providers() {
+  network_providers_.Clear();
+}
+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 network_providers_.Get(index);
+}
+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 ::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 network_providers_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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_;
+}
+
+// optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Channel chrome_update_channel = 5;
+inline bool ClientIncidentReport_EnvironmentData_Process::has_chrome_update_channel() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_has_chrome_update_channel() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_has_chrome_update_channel() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_chrome_update_channel() {
+  chrome_update_channel_ = 0;
+  clear_has_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 static_cast< ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel >(chrome_update_channel_);
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_chrome_update_channel(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel value) {
+  assert(::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Channel_IsValid(value));
+  set_has_chrome_update_channel();
+  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::has_uptime_msec() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_has_uptime_msec() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_has_uptime_msec() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_uptime_msec() {
+  uptime_msec_ = GOOGLE_LONGLONG(0);
+  clear_has_uptime_msec();
+}
+inline ::google::protobuf::int64 ClientIncidentReport_EnvironmentData_Process::uptime_msec() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.uptime_msec)
+  return uptime_msec_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_uptime_msec(::google::protobuf::int64 value) {
+  set_has_uptime_msec();
+  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::has_metrics_consent() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_has_metrics_consent() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_has_metrics_consent() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_metrics_consent() {
+  metrics_consent_ = false;
+  clear_has_metrics_consent();
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::metrics_consent() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.metrics_consent)
+  return metrics_consent_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_metrics_consent(bool value) {
+  set_has_metrics_consent();
+  metrics_consent_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.metrics_consent)
+}
+
+// optional bool extended_consent = 8;
+inline bool ClientIncidentReport_EnvironmentData_Process::has_extended_consent() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_has_extended_consent() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_has_extended_consent() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_extended_consent() {
+  extended_consent_ = false;
+  clear_has_extended_consent();
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::extended_consent() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.extended_consent)
+  return extended_consent_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_extended_consent(bool value) {
+  set_has_extended_consent();
+  extended_consent_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.extended_consent)
+}
+
+// repeated .safe_browsing.ClientIncidentReport.EnvironmentData.Process.Dll dll = 9;
+inline int ClientIncidentReport_EnvironmentData_Process::dll_size() const {
+  return dll_.size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_dll() {
+  dll_.Clear();
+}
+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 dll_.Get(index);
+}
+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 ::safe_browsing::ClientIncidentReport_EnvironmentData_Process_Dll* ClientIncidentReport_EnvironmentData_Process::add_dll() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.EnvironmentData.Process.dll)
+  return dll_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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_;
+}
+
+// repeated string blacklisted_dll = 10;
+inline int ClientIncidentReport_EnvironmentData_Process::blacklisted_dll_size() const {
+  return blacklisted_dll_.size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_blacklisted_dll() {
+  blacklisted_dll_.Clear();
+}
+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 blacklisted_dll_.Get(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, const char* value) {
+  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::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(const char* value) {
+  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 ::google::protobuf::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 ::google::protobuf::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::module_state_size() const {
+  return module_state_.size();
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_module_state() {
+  module_state_.Clear();
+}
+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 module_state_.Get(index);
+}
+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 ::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 module_state_.Add();
+}
+inline const ::google::protobuf::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_;
+}
+inline ::google::protobuf::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_;
+}
+
+// optional bool field_trial_participant = 12;
+inline bool ClientIncidentReport_EnvironmentData_Process::has_field_trial_participant() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_has_field_trial_participant() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_has_field_trial_participant() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::clear_field_trial_participant() {
+  field_trial_participant_ = false;
+  clear_has_field_trial_participant();
+}
+inline bool ClientIncidentReport_EnvironmentData_Process::field_trial_participant() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.Process.field_trial_participant)
+  return field_trial_participant_;
+}
+inline void ClientIncidentReport_EnvironmentData_Process::set_field_trial_participant(bool value) {
+  set_has_field_trial_participant();
+  field_trial_participant_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.EnvironmentData.Process.field_trial_participant)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_EnvironmentData
+
+// optional .safe_browsing.ClientIncidentReport.EnvironmentData.OS os = 1;
+inline bool ClientIncidentReport_EnvironmentData::has_os() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData::set_has_os() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData::clear_has_os() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_EnvironmentData::clear_os() {
+  if (os_ != NULL) os_->::safe_browsing::ClientIncidentReport_EnvironmentData_OS::Clear();
+  clear_has_os();
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_OS& ClientIncidentReport_EnvironmentData::os() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.os)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return os_ != NULL ? *os_ : *default_instance().os_;
+#else
+  return os_ != NULL ? *os_ : *default_instance_->os_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* ClientIncidentReport_EnvironmentData::mutable_os() {
+  set_has_os();
+  if (os_ == NULL) os_ = new ::safe_browsing::ClientIncidentReport_EnvironmentData_OS;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.os)
+  return os_;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* ClientIncidentReport_EnvironmentData::release_os() {
+  clear_has_os();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_OS* temp = os_;
+  os_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_EnvironmentData::set_allocated_os(::safe_browsing::ClientIncidentReport_EnvironmentData_OS* os) {
+  delete os_;
+  os_ = os;
+  if (os) {
+    set_has_os();
+  } else {
+    clear_has_os();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.os)
+}
+
+// optional .safe_browsing.ClientIncidentReport.EnvironmentData.Machine machine = 2;
+inline bool ClientIncidentReport_EnvironmentData::has_machine() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData::set_has_machine() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData::clear_has_machine() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_EnvironmentData::clear_machine() {
+  if (machine_ != NULL) machine_->::safe_browsing::ClientIncidentReport_EnvironmentData_Machine::Clear();
+  clear_has_machine();
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine& ClientIncidentReport_EnvironmentData::machine() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.machine)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return machine_ != NULL ? *machine_ : *default_instance().machine_;
+#else
+  return machine_ != NULL ? *machine_ : *default_instance_->machine_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* ClientIncidentReport_EnvironmentData::mutable_machine() {
+  set_has_machine();
+  if (machine_ == NULL) machine_ = new ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.machine)
+  return machine_;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* ClientIncidentReport_EnvironmentData::release_machine() {
+  clear_has_machine();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* temp = machine_;
+  machine_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_EnvironmentData::set_allocated_machine(::safe_browsing::ClientIncidentReport_EnvironmentData_Machine* machine) {
+  delete machine_;
+  machine_ = machine;
+  if (machine) {
+    set_has_machine();
+  } else {
+    clear_has_machine();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.machine)
+}
+
+// optional .safe_browsing.ClientIncidentReport.EnvironmentData.Process process = 3;
+inline bool ClientIncidentReport_EnvironmentData::has_process() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_EnvironmentData::set_has_process() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_EnvironmentData::clear_has_process() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_EnvironmentData::clear_process() {
+  if (process_ != NULL) process_->::safe_browsing::ClientIncidentReport_EnvironmentData_Process::Clear();
+  clear_has_process();
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData_Process& ClientIncidentReport_EnvironmentData::process() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.EnvironmentData.process)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return process_ != NULL ? *process_ : *default_instance().process_;
+#else
+  return process_ != NULL ? *process_ : *default_instance_->process_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* ClientIncidentReport_EnvironmentData::mutable_process() {
+  set_has_process();
+  if (process_ == NULL) process_ = new ::safe_browsing::ClientIncidentReport_EnvironmentData_Process;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.EnvironmentData.process)
+  return process_;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* ClientIncidentReport_EnvironmentData::release_process() {
+  clear_has_process();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData_Process* temp = process_;
+  process_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_EnvironmentData::set_allocated_process(::safe_browsing::ClientIncidentReport_EnvironmentData_Process* process) {
+  delete process_;
+  process_ = process;
+  if (process) {
+    set_has_process();
+  } else {
+    clear_has_process();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.EnvironmentData.process)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport_ExtensionData_ExtensionInfo
+
+// optional string id = 1;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_id() {
+  if (id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_->clear();
+  }
+  clear_has_id();
+}
+inline const ::std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::id() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id)
+  return *id_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_id(const ::std::string& value) {
+  set_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_ = new ::std::string;
+  }
+  id_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id)
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_id(const char* value) {
+  set_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_ = new ::std::string;
+  }
+  id_->assign(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) {
+  set_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_ = new ::std::string;
+  }
+  id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id)
+}
+inline ::std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_id() {
+  set_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id)
+  return id_;
+}
+inline ::std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::release_id() {
+  clear_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = id_;
+    id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_id(::std::string* id) {
+  if (id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete id_;
+  }
+  if (id) {
+    set_has_id();
+    id_ = id;
+  } else {
+    clear_has_id();
+    id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.id)
+}
+
+// optional string version = 2;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_version() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_version() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_version() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_version() {
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_->clear();
+  }
+  clear_has_version();
+}
+inline const ::std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version)
+  return *version_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_version(const ::std::string& value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version)
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_version(const char* value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(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) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version)
+}
+inline ::std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_version() {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version)
+  return version_;
+}
+inline ::std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::release_version() {
+  clear_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = version_;
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_version(::std::string* version) {
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete version_;
+  }
+  if (version) {
+    set_has_version();
+    version_ = version;
+  } else {
+    clear_has_version();
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.version)
+}
+
+// optional string name = 3;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_name() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_name() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_name() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name)
+  return *name_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name)
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(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) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name)
+}
+inline ::std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name)
+  return name_;
+}
+inline ::std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.name)
+}
+
+// optional string description = 4;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_description() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_description() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_description() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_description() {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_->clear();
+  }
+  clear_has_description();
+}
+inline const ::std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::description() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description)
+  return *description_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_description(const ::std::string& value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description)
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_description(const char* value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(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) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description)
+}
+inline ::std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_description() {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.description)
+  return description_;
+}
+inline ::std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::release_description() {
+  clear_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = description_;
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_description(::std::string* description) {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (description) {
+    set_has_description();
+    description_ = description;
+  } else {
+    clear_has_description();
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::has_state() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_state() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_state() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_state() {
+  state_ = 0;
+  clear_has_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 static_cast< ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState >(state_);
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_state(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState value) {
+  assert(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo_ExtensionState_IsValid(value));
+  set_has_state();
+  state_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.state)
+}
+
+// optional int32 type = 6;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_type() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_type() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_type() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_type() {
+  type_ = 0;
+  clear_has_type();
+}
+inline ::google::protobuf::int32 ClientIncidentReport_ExtensionData_ExtensionInfo::type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.type)
+  return type_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_type(::google::protobuf::int32 value) {
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.type)
+}
+
+// optional string update_url = 7;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_update_url() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_update_url() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_update_url() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_update_url() {
+  if (update_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    update_url_->clear();
+  }
+  clear_has_update_url();
+}
+inline const ::std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::update_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url)
+  return *update_url_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_update_url(const ::std::string& value) {
+  set_has_update_url();
+  if (update_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    update_url_ = new ::std::string;
+  }
+  update_url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url)
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_update_url(const char* value) {
+  set_has_update_url();
+  if (update_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    update_url_ = new ::std::string;
+  }
+  update_url_->assign(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) {
+  set_has_update_url();
+  if (update_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    update_url_ = new ::std::string;
+  }
+  update_url_->assign(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::mutable_update_url() {
+  set_has_update_url();
+  if (update_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    update_url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url)
+  return update_url_;
+}
+inline ::std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::release_update_url() {
+  clear_has_update_url();
+  if (update_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = update_url_;
+    update_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_update_url(::std::string* update_url) {
+  if (update_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete update_url_;
+  }
+  if (update_url) {
+    set_has_update_url();
+    update_url_ = update_url;
+  } else {
+    clear_has_update_url();
+    update_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.update_url)
+}
+
+// optional bool has_signature_validation = 8;
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::has_has_signature_validation() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_has_signature_validation() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_has_signature_validation() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_signature_validation() {
+  has_signature_validation_ = false;
+  clear_has_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 has_signature_validation_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_signature_validation(bool value) {
+  set_has_has_signature_validation();
+  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::has_signature_is_valid() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_signature_is_valid() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_signature_is_valid() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_signature_is_valid() {
+  signature_is_valid_ = false;
+  clear_has_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 signature_is_valid_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_signature_is_valid(bool value) {
+  set_has_signature_is_valid();
+  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::has_installed_by_custodian() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_installed_by_custodian() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_installed_by_custodian() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_installed_by_custodian() {
+  installed_by_custodian_ = false;
+  clear_has_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 installed_by_custodian_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_installed_by_custodian(bool value) {
+  set_has_installed_by_custodian();
+  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::has_installed_by_default() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_installed_by_default() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_installed_by_default() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_installed_by_default() {
+  installed_by_default_ = false;
+  clear_has_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 installed_by_default_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_installed_by_default(bool value) {
+  set_has_installed_by_default();
+  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::has_installed_by_oem() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_installed_by_oem() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_installed_by_oem() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_installed_by_oem() {
+  installed_by_oem_ = false;
+  clear_has_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 installed_by_oem_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_installed_by_oem(bool value) {
+  set_has_installed_by_oem();
+  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::has_from_bookmark() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_from_bookmark() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_from_bookmark() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_from_bookmark() {
+  from_bookmark_ = false;
+  clear_has_from_bookmark();
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::from_bookmark() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.from_bookmark)
+  return from_bookmark_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_from_bookmark(bool value) {
+  set_has_from_bookmark();
+  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::has_from_webstore() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_from_webstore() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_from_webstore() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_from_webstore() {
+  from_webstore_ = false;
+  clear_has_from_webstore();
+}
+inline bool ClientIncidentReport_ExtensionData_ExtensionInfo::from_webstore() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.from_webstore)
+  return from_webstore_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_from_webstore(bool value) {
+  set_has_from_webstore();
+  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::has_converted_from_user_script() const {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_converted_from_user_script() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_converted_from_user_script() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_converted_from_user_script() {
+  converted_from_user_script_ = false;
+  clear_has_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 converted_from_user_script_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_converted_from_user_script(bool value) {
+  set_has_converted_from_user_script();
+  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::has_may_be_untrusted() const {
+  return (_has_bits_[0] & 0x00008000u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_may_be_untrusted() {
+  _has_bits_[0] |= 0x00008000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_may_be_untrusted() {
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_may_be_untrusted() {
+  may_be_untrusted_ = false;
+  clear_has_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 may_be_untrusted_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_may_be_untrusted(bool value) {
+  set_has_may_be_untrusted();
+  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::has_install_time_msec() const {
+  return (_has_bits_[0] & 0x00010000u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_install_time_msec() {
+  _has_bits_[0] |= 0x00010000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_install_time_msec() {
+  _has_bits_[0] &= ~0x00010000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_install_time_msec() {
+  install_time_msec_ = GOOGLE_LONGLONG(0);
+  clear_has_install_time_msec();
+}
+inline ::google::protobuf::int64 ClientIncidentReport_ExtensionData_ExtensionInfo::install_time_msec() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.install_time_msec)
+  return install_time_msec_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_install_time_msec(::google::protobuf::int64 value) {
+  set_has_install_time_msec();
+  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::has_manifest_location_type() const {
+  return (_has_bits_[0] & 0x00020000u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_manifest_location_type() {
+  _has_bits_[0] |= 0x00020000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_manifest_location_type() {
+  _has_bits_[0] &= ~0x00020000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_manifest_location_type() {
+  manifest_location_type_ = 0;
+  clear_has_manifest_location_type();
+}
+inline ::google::protobuf::int32 ClientIncidentReport_ExtensionData_ExtensionInfo::manifest_location_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest_location_type)
+  return manifest_location_type_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_manifest_location_type(::google::protobuf::int32 value) {
+  set_has_manifest_location_type();
+  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::has_manifest() const {
+  return (_has_bits_[0] & 0x00040000u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_has_manifest() {
+  _has_bits_[0] |= 0x00040000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_has_manifest() {
+  _has_bits_[0] &= ~0x00040000u;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::clear_manifest() {
+  if (manifest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    manifest_->clear();
+  }
+  clear_has_manifest();
+}
+inline const ::std::string& ClientIncidentReport_ExtensionData_ExtensionInfo::manifest() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest)
+  return *manifest_;
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_manifest(const ::std::string& value) {
+  set_has_manifest();
+  if (manifest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    manifest_ = new ::std::string;
+  }
+  manifest_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest)
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_manifest(const char* value) {
+  set_has_manifest();
+  if (manifest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    manifest_ = new ::std::string;
+  }
+  manifest_->assign(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) {
+  set_has_manifest();
+  if (manifest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    manifest_ = new ::std::string;
+  }
+  manifest_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest)
+}
+inline ::std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::mutable_manifest() {
+  set_has_manifest();
+  if (manifest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    manifest_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.ExtensionInfo.manifest)
+  return manifest_;
+}
+inline ::std::string* ClientIncidentReport_ExtensionData_ExtensionInfo::release_manifest() {
+  clear_has_manifest();
+  if (manifest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = manifest_;
+    manifest_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_ExtensionData_ExtensionInfo::set_allocated_manifest(::std::string* manifest) {
+  if (manifest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete manifest_;
+  }
+  if (manifest) {
+    set_has_manifest();
+    manifest_ = manifest;
+  } else {
+    clear_has_manifest();
+    manifest_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::has_last_installed_extension() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_ExtensionData::set_has_last_installed_extension() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_ExtensionData::clear_has_last_installed_extension() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_ExtensionData::clear_last_installed_extension() {
+  if (last_installed_extension_ != NULL) last_installed_extension_->::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo::Clear();
+  clear_has_last_installed_extension();
+}
+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)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return last_installed_extension_ != NULL ? *last_installed_extension_ : *default_instance().last_installed_extension_;
+#else
+  return last_installed_extension_ != NULL ? *last_installed_extension_ : *default_instance_->last_installed_extension_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* ClientIncidentReport_ExtensionData::mutable_last_installed_extension() {
+  set_has_last_installed_extension();
+  if (last_installed_extension_ == NULL) last_installed_extension_ = new ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.ExtensionData.last_installed_extension)
+  return last_installed_extension_;
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* ClientIncidentReport_ExtensionData::release_last_installed_extension() {
+  clear_has_last_installed_extension();
+  ::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* temp = last_installed_extension_;
+  last_installed_extension_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport_ExtensionData::set_allocated_last_installed_extension(::safe_browsing::ClientIncidentReport_ExtensionData_ExtensionInfo* last_installed_extension) {
+  delete last_installed_extension_;
+  last_installed_extension_ = last_installed_extension;
+  if (last_installed_extension) {
+    set_has_last_installed_extension();
+  } else {
+    clear_has_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::has_file_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_has_file_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_has_file_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_file_type() {
+  if (file_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_type_->clear();
+  }
+  clear_has_file_type();
+}
+inline const ::std::string& ClientIncidentReport_NonBinaryDownloadDetails::file_type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type)
+  return *file_type_;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_file_type(const ::std::string& value) {
+  set_has_file_type();
+  if (file_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_type_ = new ::std::string;
+  }
+  file_type_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type)
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_file_type(const char* value) {
+  set_has_file_type();
+  if (file_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_type_ = new ::std::string;
+  }
+  file_type_->assign(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) {
+  set_has_file_type();
+  if (file_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_type_ = new ::std::string;
+  }
+  file_type_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type)
+}
+inline ::std::string* ClientIncidentReport_NonBinaryDownloadDetails::mutable_file_type() {
+  set_has_file_type();
+  if (file_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    file_type_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type)
+  return file_type_;
+}
+inline ::std::string* ClientIncidentReport_NonBinaryDownloadDetails::release_file_type() {
+  clear_has_file_type();
+  if (file_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = file_type_;
+    file_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_allocated_file_type(::std::string* file_type) {
+  if (file_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete file_type_;
+  }
+  if (file_type) {
+    set_has_file_type();
+    file_type_ = file_type;
+  } else {
+    clear_has_file_type();
+    file_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.file_type)
+}
+
+// optional bytes url_spec_sha256 = 2;
+inline bool ClientIncidentReport_NonBinaryDownloadDetails::has_url_spec_sha256() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_has_url_spec_sha256() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_has_url_spec_sha256() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_url_spec_sha256() {
+  if (url_spec_sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_spec_sha256_->clear();
+  }
+  clear_has_url_spec_sha256();
+}
+inline const ::std::string& ClientIncidentReport_NonBinaryDownloadDetails::url_spec_sha256() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256)
+  return *url_spec_sha256_;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_url_spec_sha256(const ::std::string& value) {
+  set_has_url_spec_sha256();
+  if (url_spec_sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_spec_sha256_ = new ::std::string;
+  }
+  url_spec_sha256_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256)
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_url_spec_sha256(const char* value) {
+  set_has_url_spec_sha256();
+  if (url_spec_sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_spec_sha256_ = new ::std::string;
+  }
+  url_spec_sha256_->assign(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) {
+  set_has_url_spec_sha256();
+  if (url_spec_sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_spec_sha256_ = new ::std::string;
+  }
+  url_spec_sha256_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256)
+}
+inline ::std::string* ClientIncidentReport_NonBinaryDownloadDetails::mutable_url_spec_sha256() {
+  set_has_url_spec_sha256();
+  if (url_spec_sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_spec_sha256_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256)
+  return url_spec_sha256_;
+}
+inline ::std::string* ClientIncidentReport_NonBinaryDownloadDetails::release_url_spec_sha256() {
+  clear_has_url_spec_sha256();
+  if (url_spec_sha256_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_spec_sha256_;
+    url_spec_sha256_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_allocated_url_spec_sha256(::std::string* url_spec_sha256) {
+  if (url_spec_sha256_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_spec_sha256_;
+  }
+  if (url_spec_sha256) {
+    set_has_url_spec_sha256();
+    url_spec_sha256_ = url_spec_sha256;
+  } else {
+    clear_has_url_spec_sha256();
+    url_spec_sha256_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.url_spec_sha256)
+}
+
+// optional string host = 3;
+inline bool ClientIncidentReport_NonBinaryDownloadDetails::has_host() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_has_host() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_has_host() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_host() {
+  if (host_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    host_->clear();
+  }
+  clear_has_host();
+}
+inline const ::std::string& ClientIncidentReport_NonBinaryDownloadDetails::host() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host)
+  return *host_;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_host(const ::std::string& value) {
+  set_has_host();
+  if (host_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    host_ = new ::std::string;
+  }
+  host_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host)
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_host(const char* value) {
+  set_has_host();
+  if (host_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    host_ = new ::std::string;
+  }
+  host_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host)
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_host(const char* value, size_t size) {
+  set_has_host();
+  if (host_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    host_ = new ::std::string;
+  }
+  host_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host)
+}
+inline ::std::string* ClientIncidentReport_NonBinaryDownloadDetails::mutable_host() {
+  set_has_host();
+  if (host_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    host_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host)
+  return host_;
+}
+inline ::std::string* ClientIncidentReport_NonBinaryDownloadDetails::release_host() {
+  clear_has_host();
+  if (host_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = host_;
+    host_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_allocated_host(::std::string* host) {
+  if (host_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete host_;
+  }
+  if (host) {
+    set_has_host();
+    host_ = host;
+  } else {
+    clear_has_host();
+    host_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.host)
+}
+
+// optional int64 length = 4;
+inline bool ClientIncidentReport_NonBinaryDownloadDetails::has_length() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_has_length() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_has_length() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::clear_length() {
+  length_ = GOOGLE_LONGLONG(0);
+  clear_has_length();
+}
+inline ::google::protobuf::int64 ClientIncidentReport_NonBinaryDownloadDetails::length() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.length)
+  return length_;
+}
+inline void ClientIncidentReport_NonBinaryDownloadDetails::set_length(::google::protobuf::int64 value) {
+  set_has_length();
+  length_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentReport.NonBinaryDownloadDetails.length)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentReport
+
+// repeated .safe_browsing.ClientIncidentReport.IncidentData incident = 1;
+inline int ClientIncidentReport::incident_size() const {
+  return incident_.size();
+}
+inline void ClientIncidentReport::clear_incident() {
+  incident_.Clear();
+}
+inline const ::safe_browsing::ClientIncidentReport_IncidentData& ClientIncidentReport::incident(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.incident)
+  return incident_.Get(index);
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData* ClientIncidentReport::mutable_incident(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.incident)
+  return incident_.Mutable(index);
+}
+inline ::safe_browsing::ClientIncidentReport_IncidentData* ClientIncidentReport::add_incident() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentReport.incident)
+  return incident_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData >&
+ClientIncidentReport::incident() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentReport.incident)
+  return incident_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentReport_IncidentData >*
+ClientIncidentReport::mutable_incident() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentReport.incident)
+  return &incident_;
+}
+
+// optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+inline bool ClientIncidentReport::has_download() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentReport::set_has_download() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentReport::clear_has_download() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentReport::clear_download() {
+  if (download_ != NULL) download_->::safe_browsing::ClientIncidentReport_DownloadDetails::Clear();
+  clear_has_download();
+}
+inline const ::safe_browsing::ClientIncidentReport_DownloadDetails& ClientIncidentReport::download() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.download)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return download_ != NULL ? *download_ : *default_instance().download_;
+#else
+  return download_ != NULL ? *download_ : *default_instance_->download_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_DownloadDetails* ClientIncidentReport::mutable_download() {
+  set_has_download();
+  if (download_ == NULL) download_ = new ::safe_browsing::ClientIncidentReport_DownloadDetails;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.download)
+  return download_;
+}
+inline ::safe_browsing::ClientIncidentReport_DownloadDetails* ClientIncidentReport::release_download() {
+  clear_has_download();
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* temp = download_;
+  download_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport::set_allocated_download(::safe_browsing::ClientIncidentReport_DownloadDetails* download) {
+  delete download_;
+  download_ = download;
+  if (download) {
+    set_has_download();
+  } else {
+    clear_has_download();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.download)
+}
+
+// optional .safe_browsing.ClientIncidentReport.EnvironmentData environment = 3;
+inline bool ClientIncidentReport::has_environment() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientIncidentReport::set_has_environment() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientIncidentReport::clear_has_environment() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientIncidentReport::clear_environment() {
+  if (environment_ != NULL) environment_->::safe_browsing::ClientIncidentReport_EnvironmentData::Clear();
+  clear_has_environment();
+}
+inline const ::safe_browsing::ClientIncidentReport_EnvironmentData& ClientIncidentReport::environment() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.environment)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return environment_ != NULL ? *environment_ : *default_instance().environment_;
+#else
+  return environment_ != NULL ? *environment_ : *default_instance_->environment_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData* ClientIncidentReport::mutable_environment() {
+  set_has_environment();
+  if (environment_ == NULL) environment_ = new ::safe_browsing::ClientIncidentReport_EnvironmentData;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.environment)
+  return environment_;
+}
+inline ::safe_browsing::ClientIncidentReport_EnvironmentData* ClientIncidentReport::release_environment() {
+  clear_has_environment();
+  ::safe_browsing::ClientIncidentReport_EnvironmentData* temp = environment_;
+  environment_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport::set_allocated_environment(::safe_browsing::ClientIncidentReport_EnvironmentData* environment) {
+  delete environment_;
+  environment_ = environment;
+  if (environment) {
+    set_has_environment();
+  } else {
+    clear_has_environment();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.environment)
+}
+
+// optional .safe_browsing.ChromeUserPopulation population = 7;
+inline bool ClientIncidentReport::has_population() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientIncidentReport::set_has_population() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientIncidentReport::clear_has_population() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientIncidentReport::clear_population() {
+  if (population_ != NULL) population_->::safe_browsing::ChromeUserPopulation::Clear();
+  clear_has_population();
+}
+inline const ::safe_browsing::ChromeUserPopulation& ClientIncidentReport::population() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.population)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return population_ != NULL ? *population_ : *default_instance().population_;
+#else
+  return population_ != NULL ? *population_ : *default_instance_->population_;
+#endif
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientIncidentReport::mutable_population() {
+  set_has_population();
+  if (population_ == NULL) population_ = new ::safe_browsing::ChromeUserPopulation;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.population)
+  return population_;
+}
+inline ::safe_browsing::ChromeUserPopulation* ClientIncidentReport::release_population() {
+  clear_has_population();
+  ::safe_browsing::ChromeUserPopulation* temp = population_;
+  population_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport::set_allocated_population(::safe_browsing::ChromeUserPopulation* population) {
+  delete population_;
+  population_ = population;
+  if (population) {
+    set_has_population();
+  } else {
+    clear_has_population();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentReport.population)
+}
+
+// optional .safe_browsing.ClientIncidentReport.ExtensionData extension_data = 8;
+inline bool ClientIncidentReport::has_extension_data() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientIncidentReport::set_has_extension_data() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientIncidentReport::clear_has_extension_data() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientIncidentReport::clear_extension_data() {
+  if (extension_data_ != NULL) extension_data_->::safe_browsing::ClientIncidentReport_ExtensionData::Clear();
+  clear_has_extension_data();
+}
+inline const ::safe_browsing::ClientIncidentReport_ExtensionData& ClientIncidentReport::extension_data() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.extension_data)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return extension_data_ != NULL ? *extension_data_ : *default_instance().extension_data_;
+#else
+  return extension_data_ != NULL ? *extension_data_ : *default_instance_->extension_data_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData* ClientIncidentReport::mutable_extension_data() {
+  set_has_extension_data();
+  if (extension_data_ == NULL) extension_data_ = new ::safe_browsing::ClientIncidentReport_ExtensionData;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.extension_data)
+  return extension_data_;
+}
+inline ::safe_browsing::ClientIncidentReport_ExtensionData* ClientIncidentReport::release_extension_data() {
+  clear_has_extension_data();
+  ::safe_browsing::ClientIncidentReport_ExtensionData* temp = extension_data_;
+  extension_data_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport::set_allocated_extension_data(::safe_browsing::ClientIncidentReport_ExtensionData* extension_data) {
+  delete extension_data_;
+  extension_data_ = extension_data;
+  if (extension_data) {
+    set_has_extension_data();
+  } else {
+    clear_has_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::has_non_binary_download() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClientIncidentReport::set_has_non_binary_download() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClientIncidentReport::clear_has_non_binary_download() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClientIncidentReport::clear_non_binary_download() {
+  if (non_binary_download_ != NULL) non_binary_download_->::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails::Clear();
+  clear_has_non_binary_download();
+}
+inline const ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails& ClientIncidentReport::non_binary_download() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentReport.non_binary_download)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return non_binary_download_ != NULL ? *non_binary_download_ : *default_instance().non_binary_download_;
+#else
+  return non_binary_download_ != NULL ? *non_binary_download_ : *default_instance_->non_binary_download_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* ClientIncidentReport::mutable_non_binary_download() {
+  set_has_non_binary_download();
+  if (non_binary_download_ == NULL) non_binary_download_ = new ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentReport.non_binary_download)
+  return non_binary_download_;
+}
+inline ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* ClientIncidentReport::release_non_binary_download() {
+  clear_has_non_binary_download();
+  ::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* temp = non_binary_download_;
+  non_binary_download_ = NULL;
+  return temp;
+}
+inline void ClientIncidentReport::set_allocated_non_binary_download(::safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails* non_binary_download) {
+  delete non_binary_download_;
+  non_binary_download_ = non_binary_download;
+  if (non_binary_download) {
+    set_has_non_binary_download();
+  } else {
+    clear_has_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::has_dll_index() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentResponse_EnvironmentRequest::set_has_dll_index() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentResponse_EnvironmentRequest::clear_has_dll_index() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentResponse_EnvironmentRequest::clear_dll_index() {
+  dll_index_ = 0;
+  clear_has_dll_index();
+}
+inline ::google::protobuf::int32 ClientIncidentResponse_EnvironmentRequest::dll_index() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentResponse.EnvironmentRequest.dll_index)
+  return dll_index_;
+}
+inline void ClientIncidentResponse_EnvironmentRequest::set_dll_index(::google::protobuf::int32 value) {
+  set_has_dll_index();
+  dll_index_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentResponse.EnvironmentRequest.dll_index)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIncidentResponse
+
+// optional bytes token = 1;
+inline bool ClientIncidentResponse::has_token() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientIncidentResponse::set_has_token() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientIncidentResponse::clear_has_token() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientIncidentResponse::clear_token() {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_->clear();
+  }
+  clear_has_token();
+}
+inline const ::std::string& ClientIncidentResponse::token() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentResponse.token)
+  return *token_;
+}
+inline void ClientIncidentResponse::set_token(const ::std::string& value) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentResponse.token)
+}
+inline void ClientIncidentResponse::set_token(const char* value) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientIncidentResponse.token)
+}
+inline void ClientIncidentResponse::set_token(const void* value, size_t size) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientIncidentResponse.token)
+}
+inline ::std::string* ClientIncidentResponse::mutable_token() {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientIncidentResponse.token)
+  return token_;
+}
+inline ::std::string* ClientIncidentResponse::release_token() {
+  clear_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = token_;
+    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientIncidentResponse::set_allocated_token(::std::string* token) {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete token_;
+  }
+  if (token) {
+    set_has_token();
+    token_ = token;
+  } else {
+    clear_has_token();
+    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientIncidentResponse.token)
+}
+
+// optional bool download_requested = 2;
+inline bool ClientIncidentResponse::has_download_requested() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientIncidentResponse::set_has_download_requested() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientIncidentResponse::clear_has_download_requested() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientIncidentResponse::clear_download_requested() {
+  download_requested_ = false;
+  clear_has_download_requested();
+}
+inline bool ClientIncidentResponse::download_requested() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentResponse.download_requested)
+  return download_requested_;
+}
+inline void ClientIncidentResponse::set_download_requested(bool value) {
+  set_has_download_requested();
+  download_requested_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientIncidentResponse.download_requested)
+}
+
+// repeated .safe_browsing.ClientIncidentResponse.EnvironmentRequest environment_requests = 3;
+inline int ClientIncidentResponse::environment_requests_size() const {
+  return environment_requests_.size();
+}
+inline void ClientIncidentResponse::clear_environment_requests() {
+  environment_requests_.Clear();
+}
+inline const ::safe_browsing::ClientIncidentResponse_EnvironmentRequest& ClientIncidentResponse::environment_requests(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientIncidentResponse.environment_requests)
+  return environment_requests_.Get(index);
+}
+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 ::safe_browsing::ClientIncidentResponse_EnvironmentRequest* ClientIncidentResponse::add_environment_requests() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientIncidentResponse.environment_requests)
+  return environment_requests_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest >&
+ClientIncidentResponse::environment_requests() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientIncidentResponse.environment_requests)
+  return environment_requests_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientIncidentResponse_EnvironmentRequest >*
+ClientIncidentResponse::mutable_environment_requests() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientIncidentResponse.environment_requests)
+  return &environment_requests_;
+}
+
+// -------------------------------------------------------------------
+
+// DownloadMetadata
+
+// optional uint32 download_id = 1;
+inline bool DownloadMetadata::has_download_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DownloadMetadata::set_has_download_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DownloadMetadata::clear_has_download_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DownloadMetadata::clear_download_id() {
+  download_id_ = 0u;
+  clear_has_download_id();
+}
+inline ::google::protobuf::uint32 DownloadMetadata::download_id() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.DownloadMetadata.download_id)
+  return download_id_;
+}
+inline void DownloadMetadata::set_download_id(::google::protobuf::uint32 value) {
+  set_has_download_id();
+  download_id_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.DownloadMetadata.download_id)
+}
+
+// optional .safe_browsing.ClientIncidentReport.DownloadDetails download = 2;
+inline bool DownloadMetadata::has_download() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DownloadMetadata::set_has_download() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DownloadMetadata::clear_has_download() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DownloadMetadata::clear_download() {
+  if (download_ != NULL) download_->::safe_browsing::ClientIncidentReport_DownloadDetails::Clear();
+  clear_has_download();
+}
+inline const ::safe_browsing::ClientIncidentReport_DownloadDetails& DownloadMetadata::download() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.DownloadMetadata.download)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return download_ != NULL ? *download_ : *default_instance().download_;
+#else
+  return download_ != NULL ? *download_ : *default_instance_->download_;
+#endif
+}
+inline ::safe_browsing::ClientIncidentReport_DownloadDetails* DownloadMetadata::mutable_download() {
+  set_has_download();
+  if (download_ == NULL) download_ = new ::safe_browsing::ClientIncidentReport_DownloadDetails;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.DownloadMetadata.download)
+  return download_;
+}
+inline ::safe_browsing::ClientIncidentReport_DownloadDetails* DownloadMetadata::release_download() {
+  clear_has_download();
+  ::safe_browsing::ClientIncidentReport_DownloadDetails* temp = download_;
+  download_ = NULL;
+  return temp;
+}
+inline void DownloadMetadata::set_allocated_download(::safe_browsing::ClientIncidentReport_DownloadDetails* download) {
+  delete download_;
+  download_ = download;
+  if (download) {
+    set_has_download();
+  } else {
+    clear_has_download();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.DownloadMetadata.download)
+}
+
+// -------------------------------------------------------------------
+
+// ClientSafeBrowsingReportRequest_HTTPHeader
+
+// required bytes name = 1;
+inline bool ClientSafeBrowsingReportRequest_HTTPHeader::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_HTTPHeader::name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name)
+  return *name_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_name(const void* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPHeader::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name)
+  return name_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPHeader::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.name)
+}
+
+// optional bytes value = 2;
+inline bool ClientSafeBrowsingReportRequest_HTTPHeader::has_value() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_has_value() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::clear_has_value() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::clear_value() {
+  if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_->clear();
+  }
+  clear_has_value();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_HTTPHeader::value() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value)
+  return *value_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_value(const ::std::string& value) {
+  set_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_ = new ::std::string;
+  }
+  value_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_value(const char* value) {
+  set_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_ = new ::std::string;
+  }
+  value_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_value(const void* value, size_t size) {
+  set_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_ = new ::std::string;
+  }
+  value_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPHeader::mutable_value() {
+  set_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    value_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value)
+  return value_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPHeader::release_value() {
+  clear_has_value();
+  if (value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = value_;
+    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_HTTPHeader::set_allocated_value(::std::string* value) {
+  if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete value_;
+  }
+  if (value) {
+    set_has_value();
+    value_ = value;
+  } else {
+    clear_has_value();
+    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader.value)
+}
+
+// -------------------------------------------------------------------
+
+// ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine
+
+// optional bytes verb = 1;
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::has_verb() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_has_verb() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::clear_has_verb() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::clear_verb() {
+  if (verb_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    verb_->clear();
+  }
+  clear_has_verb();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::verb() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb)
+  return *verb_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_verb(const ::std::string& value) {
+  set_has_verb();
+  if (verb_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    verb_ = new ::std::string;
+  }
+  verb_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_verb(const char* value) {
+  set_has_verb();
+  if (verb_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    verb_ = new ::std::string;
+  }
+  verb_->assign(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) {
+  set_has_verb();
+  if (verb_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    verb_ = new ::std::string;
+  }
+  verb_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::mutable_verb() {
+  set_has_verb();
+  if (verb_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    verb_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb)
+  return verb_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::release_verb() {
+  clear_has_verb();
+  if (verb_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = verb_;
+    verb_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_allocated_verb(::std::string* verb) {
+  if (verb_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete verb_;
+  }
+  if (verb) {
+    set_has_verb();
+    verb_ = verb;
+  } else {
+    clear_has_verb();
+    verb_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.verb)
+}
+
+// optional bytes uri = 2;
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::has_uri() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_has_uri() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::clear_has_uri() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::clear_uri() {
+  if (uri_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    uri_->clear();
+  }
+  clear_has_uri();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::uri() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri)
+  return *uri_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_uri(const ::std::string& value) {
+  set_has_uri();
+  if (uri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    uri_ = new ::std::string;
+  }
+  uri_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_uri(const char* value) {
+  set_has_uri();
+  if (uri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    uri_ = new ::std::string;
+  }
+  uri_->assign(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) {
+  set_has_uri();
+  if (uri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    uri_ = new ::std::string;
+  }
+  uri_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::mutable_uri() {
+  set_has_uri();
+  if (uri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    uri_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri)
+  return uri_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::release_uri() {
+  clear_has_uri();
+  if (uri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = uri_;
+    uri_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_allocated_uri(::std::string* uri) {
+  if (uri_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete uri_;
+  }
+  if (uri) {
+    set_has_uri();
+    uri_ = uri;
+  } else {
+    clear_has_uri();
+    uri_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.uri)
+}
+
+// optional bytes version = 3;
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::has_version() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_has_version() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::clear_has_version() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::clear_version() {
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_->clear();
+  }
+  clear_has_version();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version)
+  return *version_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_version(const ::std::string& value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_version(const char* value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(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) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::mutable_version() {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.FirstLine.version)
+  return version_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::release_version() {
+  clear_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = version_;
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::set_allocated_version(::std::string* version) {
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete version_;
+  }
+  if (version) {
+    set_has_version();
+    version_ = version;
+  } else {
+    clear_has_version();
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::has_firstline() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_has_firstline() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_has_firstline() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_firstline() {
+  if (firstline_ != NULL) firstline_->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine::Clear();
+  clear_has_firstline();
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine& ClientSafeBrowsingReportRequest_HTTPRequest::firstline() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.firstline)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return firstline_ != NULL ? *firstline_ : *default_instance().firstline_;
+#else
+  return firstline_ != NULL ? *firstline_ : *default_instance_->firstline_;
+#endif
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* ClientSafeBrowsingReportRequest_HTTPRequest::mutable_firstline() {
+  set_has_firstline();
+  if (firstline_ == NULL) firstline_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.firstline)
+  return firstline_;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* ClientSafeBrowsingReportRequest_HTTPRequest::release_firstline() {
+  clear_has_firstline();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* temp = firstline_;
+  firstline_ = NULL;
+  return temp;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_allocated_firstline(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest_FirstLine* firstline) {
+  delete firstline_;
+  firstline_ = firstline;
+  if (firstline) {
+    set_has_firstline();
+  } else {
+    clear_has_firstline();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.firstline)
+}
+
+// repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+inline int ClientSafeBrowsingReportRequest_HTTPRequest::headers_size() const {
+  return headers_.size();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_headers() {
+  headers_.Clear();
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& ClientSafeBrowsingReportRequest_HTTPRequest::headers(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.headers)
+  return headers_.Get(index);
+}
+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 ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPRequest::add_headers() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.headers)
+  return headers_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >&
+ClientSafeBrowsingReportRequest_HTTPRequest::headers() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.headers)
+  return headers_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >*
+ClientSafeBrowsingReportRequest_HTTPRequest::mutable_headers() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.headers)
+  return &headers_;
+}
+
+// optional bytes body = 3;
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest::has_body() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_has_body() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_has_body() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_body() {
+  if (body_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    body_->clear();
+  }
+  clear_has_body();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_HTTPRequest::body() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body)
+  return *body_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_body(const ::std::string& value) {
+  set_has_body();
+  if (body_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    body_ = new ::std::string;
+  }
+  body_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_body(const char* value) {
+  set_has_body();
+  if (body_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    body_ = new ::std::string;
+  }
+  body_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_body(const void* value, size_t size) {
+  set_has_body();
+  if (body_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    body_ = new ::std::string;
+  }
+  body_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPRequest::mutable_body() {
+  set_has_body();
+  if (body_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    body_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body)
+  return body_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPRequest::release_body() {
+  clear_has_body();
+  if (body_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = body_;
+    body_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_allocated_body(::std::string* body) {
+  if (body_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete body_;
+  }
+  if (body) {
+    set_has_body();
+    body_ = body;
+  } else {
+    clear_has_body();
+    body_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.body)
+}
+
+// optional bytes bodydigest = 4;
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest::has_bodydigest() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_has_bodydigest() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_has_bodydigest() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_bodydigest() {
+  if (bodydigest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bodydigest_->clear();
+  }
+  clear_has_bodydigest();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_HTTPRequest::bodydigest() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest)
+  return *bodydigest_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_bodydigest(const ::std::string& value) {
+  set_has_bodydigest();
+  if (bodydigest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bodydigest_ = new ::std::string;
+  }
+  bodydigest_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_bodydigest(const char* value) {
+  set_has_bodydigest();
+  if (bodydigest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bodydigest_ = new ::std::string;
+  }
+  bodydigest_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_bodydigest(const void* value, size_t size) {
+  set_has_bodydigest();
+  if (bodydigest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bodydigest_ = new ::std::string;
+  }
+  bodydigest_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPRequest::mutable_bodydigest() {
+  set_has_bodydigest();
+  if (bodydigest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bodydigest_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest)
+  return bodydigest_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPRequest::release_bodydigest() {
+  clear_has_bodydigest();
+  if (bodydigest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = bodydigest_;
+    bodydigest_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_allocated_bodydigest(::std::string* bodydigest) {
+  if (bodydigest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete bodydigest_;
+  }
+  if (bodydigest) {
+    set_has_bodydigest();
+    bodydigest_ = bodydigest;
+  } else {
+    clear_has_bodydigest();
+    bodydigest_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodydigest)
+}
+
+// optional int32 bodylength = 5;
+inline bool ClientSafeBrowsingReportRequest_HTTPRequest::has_bodylength() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_has_bodylength() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_has_bodylength() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::clear_bodylength() {
+  bodylength_ = 0;
+  clear_has_bodylength();
+}
+inline ::google::protobuf::int32 ClientSafeBrowsingReportRequest_HTTPRequest::bodylength() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodylength)
+  return bodylength_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPRequest::set_bodylength(::google::protobuf::int32 value) {
+  set_has_bodylength();
+  bodylength_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest.bodylength)
+}
+
+// -------------------------------------------------------------------
+
+// ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine
+
+// optional int32 code = 1;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::has_code() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_has_code() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::clear_has_code() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::clear_code() {
+  code_ = 0;
+  clear_has_code();
+}
+inline ::google::protobuf::int32 ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::code() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.code)
+  return code_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_code(::google::protobuf::int32 value) {
+  set_has_code();
+  code_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.code)
+}
+
+// optional bytes reason = 2;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::has_reason() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_has_reason() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::clear_reason() {
+  if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_->clear();
+  }
+  clear_has_reason();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::reason() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.reason)
+  return *reason_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_reason(const ::std::string& value) {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.reason)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_reason(const char* value) {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.reason)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_reason(const void* value, size_t size) {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.reason)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::mutable_reason() {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.reason)
+  return reason_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::release_reason() {
+  clear_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = reason_;
+    reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_allocated_reason(::std::string* reason) {
+  if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete reason_;
+  }
+  if (reason) {
+    set_has_reason();
+    reason_ = reason;
+  } else {
+    clear_has_reason();
+    reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.reason)
+}
+
+// optional bytes version = 3;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::has_version() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_has_version() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::clear_has_version() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::clear_version() {
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_->clear();
+  }
+  clear_has_version();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::version() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version)
+  return *version_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_version(const ::std::string& value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_version(const char* value) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(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) {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  version_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::mutable_version() {
+  set_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    version_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.FirstLine.version)
+  return version_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::release_version() {
+  clear_has_version();
+  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = version_;
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::set_allocated_version(::std::string* version) {
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete version_;
+  }
+  if (version) {
+    set_has_version();
+    version_ = version;
+  } else {
+    clear_has_version();
+    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@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::has_firstline() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_has_firstline() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_has_firstline() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_firstline() {
+  if (firstline_ != NULL) firstline_->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine::Clear();
+  clear_has_firstline();
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine& ClientSafeBrowsingReportRequest_HTTPResponse::firstline() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.firstline)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return firstline_ != NULL ? *firstline_ : *default_instance().firstline_;
+#else
+  return firstline_ != NULL ? *firstline_ : *default_instance_->firstline_;
+#endif
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_firstline() {
+  set_has_firstline();
+  if (firstline_ == NULL) firstline_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.firstline)
+  return firstline_;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* ClientSafeBrowsingReportRequest_HTTPResponse::release_firstline() {
+  clear_has_firstline();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* temp = firstline_;
+  firstline_ = NULL;
+  return temp;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_allocated_firstline(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse_FirstLine* firstline) {
+  delete firstline_;
+  firstline_ = firstline;
+  if (firstline) {
+    set_has_firstline();
+  } else {
+    clear_has_firstline();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.firstline)
+}
+
+// repeated .safe_browsing.ClientSafeBrowsingReportRequest.HTTPHeader headers = 2;
+inline int ClientSafeBrowsingReportRequest_HTTPResponse::headers_size() const {
+  return headers_.size();
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_headers() {
+  headers_.Clear();
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader& ClientSafeBrowsingReportRequest_HTTPResponse::headers(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.headers)
+  return headers_.Get(index);
+}
+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 ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader* ClientSafeBrowsingReportRequest_HTTPResponse::add_headers() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.headers)
+  return headers_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >&
+ClientSafeBrowsingReportRequest_HTTPResponse::headers() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.headers)
+  return headers_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPHeader >*
+ClientSafeBrowsingReportRequest_HTTPResponse::mutable_headers() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.headers)
+  return &headers_;
+}
+
+// optional bytes body = 3;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::has_body() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_has_body() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_has_body() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_body() {
+  if (body_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    body_->clear();
+  }
+  clear_has_body();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_HTTPResponse::body() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body)
+  return *body_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_body(const ::std::string& value) {
+  set_has_body();
+  if (body_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    body_ = new ::std::string;
+  }
+  body_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_body(const char* value) {
+  set_has_body();
+  if (body_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    body_ = new ::std::string;
+  }
+  body_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_body(const void* value, size_t size) {
+  set_has_body();
+  if (body_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    body_ = new ::std::string;
+  }
+  body_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_body() {
+  set_has_body();
+  if (body_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    body_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body)
+  return body_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPResponse::release_body() {
+  clear_has_body();
+  if (body_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = body_;
+    body_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_allocated_body(::std::string* body) {
+  if (body_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete body_;
+  }
+  if (body) {
+    set_has_body();
+    body_ = body;
+  } else {
+    clear_has_body();
+    body_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.body)
+}
+
+// optional bytes bodydigest = 4;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::has_bodydigest() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_has_bodydigest() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_has_bodydigest() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_bodydigest() {
+  if (bodydigest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bodydigest_->clear();
+  }
+  clear_has_bodydigest();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_HTTPResponse::bodydigest() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest)
+  return *bodydigest_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_bodydigest(const ::std::string& value) {
+  set_has_bodydigest();
+  if (bodydigest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bodydigest_ = new ::std::string;
+  }
+  bodydigest_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_bodydigest(const char* value) {
+  set_has_bodydigest();
+  if (bodydigest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bodydigest_ = new ::std::string;
+  }
+  bodydigest_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_bodydigest(const void* value, size_t size) {
+  set_has_bodydigest();
+  if (bodydigest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bodydigest_ = new ::std::string;
+  }
+  bodydigest_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_bodydigest() {
+  set_has_bodydigest();
+  if (bodydigest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    bodydigest_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest)
+  return bodydigest_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPResponse::release_bodydigest() {
+  clear_has_bodydigest();
+  if (bodydigest_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = bodydigest_;
+    bodydigest_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_allocated_bodydigest(::std::string* bodydigest) {
+  if (bodydigest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete bodydigest_;
+  }
+  if (bodydigest) {
+    set_has_bodydigest();
+    bodydigest_ = bodydigest;
+  } else {
+    clear_has_bodydigest();
+    bodydigest_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodydigest)
+}
+
+// optional int32 bodylength = 5;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::has_bodylength() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_has_bodylength() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_has_bodylength() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_bodylength() {
+  bodylength_ = 0;
+  clear_has_bodylength();
+}
+inline ::google::protobuf::int32 ClientSafeBrowsingReportRequest_HTTPResponse::bodylength() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodylength)
+  return bodylength_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_bodylength(::google::protobuf::int32 value) {
+  set_has_bodylength();
+  bodylength_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.bodylength)
+}
+
+// optional bytes remote_ip = 6;
+inline bool ClientSafeBrowsingReportRequest_HTTPResponse::has_remote_ip() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_has_remote_ip() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_has_remote_ip() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::clear_remote_ip() {
+  if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_->clear();
+  }
+  clear_has_remote_ip();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_HTTPResponse::remote_ip() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip)
+  return *remote_ip_;
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_remote_ip(const ::std::string& value) {
+  set_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_ = new ::std::string;
+  }
+  remote_ip_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_remote_ip(const char* value) {
+  set_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_ = new ::std::string;
+  }
+  remote_ip_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip)
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_remote_ip(const void* value, size_t size) {
+  set_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_ = new ::std::string;
+  }
+  remote_ip_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPResponse::mutable_remote_ip() {
+  set_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    remote_ip_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip)
+  return remote_ip_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_HTTPResponse::release_remote_ip() {
+  clear_has_remote_ip();
+  if (remote_ip_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = remote_ip_;
+    remote_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_HTTPResponse::set_allocated_remote_ip(::std::string* remote_ip) {
+  if (remote_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete remote_ip_;
+  }
+  if (remote_ip) {
+    set_has_remote_ip();
+    remote_ip_ = remote_ip;
+  } else {
+    clear_has_remote_ip();
+    remote_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse.remote_ip)
+}
+
+// -------------------------------------------------------------------
+
+// ClientSafeBrowsingReportRequest_Resource
+
+// required int32 id = 1;
+inline bool ClientSafeBrowsingReportRequest_Resource::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_id() {
+  id_ = 0;
+  clear_has_id();
+}
+inline ::google::protobuf::int32 ClientSafeBrowsingReportRequest_Resource::id() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.id)
+  return id_;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_id(::google::protobuf::int32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.Resource.id)
+}
+
+// optional string url = 2;
+inline bool ClientSafeBrowsingReportRequest_Resource::has_url() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_has_url() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_has_url() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_url() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_->clear();
+  }
+  clear_has_url();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_Resource::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url)
+  return *url_;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_url(const ::std::string& value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url)
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_url(const char* value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url)
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_url(const char* value, size_t size) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_Resource::mutable_url() {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url)
+  return url_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_Resource::release_url() {
+  clear_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_;
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_allocated_url(::std::string* url) {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (url) {
+    set_has_url();
+    url_ = url;
+  } else {
+    clear_has_url();
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.Resource.url)
+}
+
+// optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPRequest request = 3;
+inline bool ClientSafeBrowsingReportRequest_Resource::has_request() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_has_request() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_has_request() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_request() {
+  if (request_ != NULL) request_->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest::Clear();
+  clear_has_request();
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest& ClientSafeBrowsingReportRequest_Resource::request() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.request)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return request_ != NULL ? *request_ : *default_instance().request_;
+#else
+  return request_ != NULL ? *request_ : *default_instance_->request_;
+#endif
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* ClientSafeBrowsingReportRequest_Resource::mutable_request() {
+  set_has_request();
+  if (request_ == NULL) request_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.Resource.request)
+  return request_;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* ClientSafeBrowsingReportRequest_Resource::release_request() {
+  clear_has_request();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* temp = request_;
+  request_ = NULL;
+  return temp;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_allocated_request(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPRequest* request) {
+  delete request_;
+  request_ = request;
+  if (request) {
+    set_has_request();
+  } else {
+    clear_has_request();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.Resource.request)
+}
+
+// optional .safe_browsing.ClientSafeBrowsingReportRequest.HTTPResponse response = 4;
+inline bool ClientSafeBrowsingReportRequest_Resource::has_response() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_has_response() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_has_response() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_response() {
+  if (response_ != NULL) response_->::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse::Clear();
+  clear_has_response();
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse& ClientSafeBrowsingReportRequest_Resource::response() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.response)
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return response_ != NULL ? *response_ : *default_instance().response_;
+#else
+  return response_ != NULL ? *response_ : *default_instance_->response_;
+#endif
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* ClientSafeBrowsingReportRequest_Resource::mutable_response() {
+  set_has_response();
+  if (response_ == NULL) response_ = new ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse;
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.Resource.response)
+  return response_;
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* ClientSafeBrowsingReportRequest_Resource::release_response() {
+  clear_has_response();
+  ::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* temp = response_;
+  response_ = NULL;
+  return temp;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_allocated_response(::safe_browsing::ClientSafeBrowsingReportRequest_HTTPResponse* response) {
+  delete response_;
+  response_ = response;
+  if (response) {
+    set_has_response();
+  } else {
+    clear_has_response();
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.Resource.response)
+}
+
+// optional int32 parent_id = 5;
+inline bool ClientSafeBrowsingReportRequest_Resource::has_parent_id() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_has_parent_id() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_has_parent_id() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_parent_id() {
+  parent_id_ = 0;
+  clear_has_parent_id();
+}
+inline ::google::protobuf::int32 ClientSafeBrowsingReportRequest_Resource::parent_id() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.parent_id)
+  return parent_id_;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_parent_id(::google::protobuf::int32 value) {
+  set_has_parent_id();
+  parent_id_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.Resource.parent_id)
+}
+
+// repeated int32 child_ids = 6;
+inline int ClientSafeBrowsingReportRequest_Resource::child_ids_size() const {
+  return child_ids_.size();
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_child_ids() {
+  child_ids_.Clear();
+}
+inline ::google::protobuf::int32 ClientSafeBrowsingReportRequest_Resource::child_ids(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.child_ids)
+  return child_ids_.Get(index);
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_child_ids(int index, ::google::protobuf::int32 value) {
+  child_ids_.Set(index, value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.Resource.child_ids)
+}
+inline void ClientSafeBrowsingReportRequest_Resource::add_child_ids(::google::protobuf::int32 value) {
+  child_ids_.Add(value);
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.Resource.child_ids)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+ClientSafeBrowsingReportRequest_Resource::child_ids() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientSafeBrowsingReportRequest.Resource.child_ids)
+  return child_ids_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+ClientSafeBrowsingReportRequest_Resource::mutable_child_ids() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientSafeBrowsingReportRequest.Resource.child_ids)
+  return &child_ids_;
+}
+
+// optional string tag_name = 7;
+inline bool ClientSafeBrowsingReportRequest_Resource::has_tag_name() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_has_tag_name() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_has_tag_name() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::clear_tag_name() {
+  if (tag_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    tag_name_->clear();
+  }
+  clear_has_tag_name();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest_Resource::tag_name() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name)
+  return *tag_name_;
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_tag_name(const ::std::string& value) {
+  set_has_tag_name();
+  if (tag_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    tag_name_ = new ::std::string;
+  }
+  tag_name_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name)
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_tag_name(const char* value) {
+  set_has_tag_name();
+  if (tag_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    tag_name_ = new ::std::string;
+  }
+  tag_name_->assign(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) {
+  set_has_tag_name();
+  if (tag_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    tag_name_ = new ::std::string;
+  }
+  tag_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_Resource::mutable_tag_name() {
+  set_has_tag_name();
+  if (tag_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    tag_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name)
+  return tag_name_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest_Resource::release_tag_name() {
+  clear_has_tag_name();
+  if (tag_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = tag_name_;
+    tag_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest_Resource::set_allocated_tag_name(::std::string* tag_name) {
+  if (tag_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete tag_name_;
+  }
+  if (tag_name) {
+    set_has_tag_name();
+    tag_name_ = tag_name;
+  } else {
+    clear_has_tag_name();
+    tag_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.Resource.tag_name)
+}
+
+// -------------------------------------------------------------------
+
+// ClientSafeBrowsingReportRequest
+
+// optional .safe_browsing.ClientSafeBrowsingReportRequest.ReportType type = 10;
+inline bool ClientSafeBrowsingReportRequest::has_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest::set_has_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_has_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_type() {
+  type_ = 0;
+  clear_has_type();
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_ReportType ClientSafeBrowsingReportRequest::type() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.type)
+  return static_cast< ::safe_browsing::ClientSafeBrowsingReportRequest_ReportType >(type_);
+}
+inline void ClientSafeBrowsingReportRequest::set_type(::safe_browsing::ClientSafeBrowsingReportRequest_ReportType value) {
+  assert(::safe_browsing::ClientSafeBrowsingReportRequest_ReportType_IsValid(value));
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.type)
+}
+
+// optional .safe_browsing.ClientDownloadResponse.Verdict download_verdict = 11;
+inline bool ClientSafeBrowsingReportRequest::has_download_verdict() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest::set_has_download_verdict() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_has_download_verdict() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_download_verdict() {
+  download_verdict_ = 0;
+  clear_has_download_verdict();
+}
+inline ::safe_browsing::ClientDownloadResponse_Verdict ClientSafeBrowsingReportRequest::download_verdict() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.download_verdict)
+  return static_cast< ::safe_browsing::ClientDownloadResponse_Verdict >(download_verdict_);
+}
+inline void ClientSafeBrowsingReportRequest::set_download_verdict(::safe_browsing::ClientDownloadResponse_Verdict value) {
+  assert(::safe_browsing::ClientDownloadResponse_Verdict_IsValid(value));
+  set_has_download_verdict();
+  download_verdict_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.download_verdict)
+}
+
+// optional string url = 1;
+inline bool ClientSafeBrowsingReportRequest::has_url() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest::set_has_url() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_has_url() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_url() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_->clear();
+  }
+  clear_has_url();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest::url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.url)
+  return *url_;
+}
+inline void ClientSafeBrowsingReportRequest::set_url(const ::std::string& value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.url)
+}
+inline void ClientSafeBrowsingReportRequest::set_url(const char* value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.url)
+}
+inline void ClientSafeBrowsingReportRequest::set_url(const char* value, size_t size) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.url)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest::mutable_url() {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.url)
+  return url_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest::release_url() {
+  clear_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_;
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest::set_allocated_url(::std::string* url) {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (url) {
+    set_has_url();
+    url_ = url;
+  } else {
+    clear_has_url();
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.url)
+}
+
+// optional string page_url = 2;
+inline bool ClientSafeBrowsingReportRequest::has_page_url() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest::set_has_page_url() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_has_page_url() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_page_url() {
+  if (page_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    page_url_->clear();
+  }
+  clear_has_page_url();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest::page_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.page_url)
+  return *page_url_;
+}
+inline void ClientSafeBrowsingReportRequest::set_page_url(const ::std::string& value) {
+  set_has_page_url();
+  if (page_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    page_url_ = new ::std::string;
+  }
+  page_url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.page_url)
+}
+inline void ClientSafeBrowsingReportRequest::set_page_url(const char* value) {
+  set_has_page_url();
+  if (page_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    page_url_ = new ::std::string;
+  }
+  page_url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.page_url)
+}
+inline void ClientSafeBrowsingReportRequest::set_page_url(const char* value, size_t size) {
+  set_has_page_url();
+  if (page_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    page_url_ = new ::std::string;
+  }
+  page_url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.page_url)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest::mutable_page_url() {
+  set_has_page_url();
+  if (page_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    page_url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.page_url)
+  return page_url_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest::release_page_url() {
+  clear_has_page_url();
+  if (page_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = page_url_;
+    page_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest::set_allocated_page_url(::std::string* page_url) {
+  if (page_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete page_url_;
+  }
+  if (page_url) {
+    set_has_page_url();
+    page_url_ = page_url;
+  } else {
+    clear_has_page_url();
+    page_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.page_url)
+}
+
+// optional string referrer_url = 3;
+inline bool ClientSafeBrowsingReportRequest::has_referrer_url() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest::set_has_referrer_url() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_has_referrer_url() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_referrer_url() {
+  if (referrer_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_url_->clear();
+  }
+  clear_has_referrer_url();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest::referrer_url() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url)
+  return *referrer_url_;
+}
+inline void ClientSafeBrowsingReportRequest::set_referrer_url(const ::std::string& value) {
+  set_has_referrer_url();
+  if (referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_url_ = new ::std::string;
+  }
+  referrer_url_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url)
+}
+inline void ClientSafeBrowsingReportRequest::set_referrer_url(const char* value) {
+  set_has_referrer_url();
+  if (referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_url_ = new ::std::string;
+  }
+  referrer_url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url)
+}
+inline void ClientSafeBrowsingReportRequest::set_referrer_url(const char* value, size_t size) {
+  set_has_referrer_url();
+  if (referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_url_ = new ::std::string;
+  }
+  referrer_url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest::mutable_referrer_url() {
+  set_has_referrer_url();
+  if (referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    referrer_url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url)
+  return referrer_url_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest::release_referrer_url() {
+  clear_has_referrer_url();
+  if (referrer_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = referrer_url_;
+    referrer_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest::set_allocated_referrer_url(::std::string* referrer_url) {
+  if (referrer_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete referrer_url_;
+  }
+  if (referrer_url) {
+    set_has_referrer_url();
+    referrer_url_ = referrer_url;
+  } else {
+    clear_has_referrer_url();
+    referrer_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.referrer_url)
+}
+
+// repeated .safe_browsing.ClientSafeBrowsingReportRequest.Resource resources = 4;
+inline int ClientSafeBrowsingReportRequest::resources_size() const {
+  return resources_.size();
+}
+inline void ClientSafeBrowsingReportRequest::clear_resources() {
+  resources_.Clear();
+}
+inline const ::safe_browsing::ClientSafeBrowsingReportRequest_Resource& ClientSafeBrowsingReportRequest::resources(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.resources)
+  return resources_.Get(index);
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* ClientSafeBrowsingReportRequest::mutable_resources(int index) {
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.resources)
+  return resources_.Mutable(index);
+}
+inline ::safe_browsing::ClientSafeBrowsingReportRequest_Resource* ClientSafeBrowsingReportRequest::add_resources() {
+  // @@protoc_insertion_point(field_add:safe_browsing.ClientSafeBrowsingReportRequest.resources)
+  return resources_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource >&
+ClientSafeBrowsingReportRequest::resources() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientSafeBrowsingReportRequest.resources)
+  return resources_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientSafeBrowsingReportRequest_Resource >*
+ClientSafeBrowsingReportRequest::mutable_resources() {
+  // @@protoc_insertion_point(field_mutable_list:safe_browsing.ClientSafeBrowsingReportRequest.resources)
+  return &resources_;
+}
+
+// optional bool complete = 5;
+inline bool ClientSafeBrowsingReportRequest::has_complete() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest::set_has_complete() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_has_complete() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_complete() {
+  complete_ = false;
+  clear_has_complete();
+}
+inline bool ClientSafeBrowsingReportRequest::complete() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.complete)
+  return complete_;
+}
+inline void ClientSafeBrowsingReportRequest::set_complete(bool value) {
+  set_has_complete();
+  complete_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.complete)
+}
+
+// repeated string client_asn = 6;
+inline int ClientSafeBrowsingReportRequest::client_asn_size() const {
+  return client_asn_.size();
+}
+inline void ClientSafeBrowsingReportRequest::clear_client_asn() {
+  client_asn_.Clear();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest::client_asn(int index) const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+  return client_asn_.Get(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, const char* value) {
+  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::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(const char* value) {
+  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 ::google::protobuf::RepeatedPtrField< ::std::string>&
+ClientSafeBrowsingReportRequest::client_asn() const {
+  // @@protoc_insertion_point(field_list:safe_browsing.ClientSafeBrowsingReportRequest.client_asn)
+  return client_asn_;
+}
+inline ::google::protobuf::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::has_client_country() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest::set_has_client_country() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_has_client_country() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_client_country() {
+  if (client_country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_country_->clear();
+  }
+  clear_has_client_country();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest::client_country() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.client_country)
+  return *client_country_;
+}
+inline void ClientSafeBrowsingReportRequest::set_client_country(const ::std::string& value) {
+  set_has_client_country();
+  if (client_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_country_ = new ::std::string;
+  }
+  client_country_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.client_country)
+}
+inline void ClientSafeBrowsingReportRequest::set_client_country(const char* value) {
+  set_has_client_country();
+  if (client_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_country_ = new ::std::string;
+  }
+  client_country_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.client_country)
+}
+inline void ClientSafeBrowsingReportRequest::set_client_country(const char* value, size_t size) {
+  set_has_client_country();
+  if (client_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_country_ = new ::std::string;
+  }
+  client_country_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.client_country)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest::mutable_client_country() {
+  set_has_client_country();
+  if (client_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_country_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.client_country)
+  return client_country_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest::release_client_country() {
+  clear_has_client_country();
+  if (client_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = client_country_;
+    client_country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest::set_allocated_client_country(::std::string* client_country) {
+  if (client_country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_country_;
+  }
+  if (client_country) {
+    set_has_client_country();
+    client_country_ = client_country;
+  } else {
+    clear_has_client_country();
+    client_country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.client_country)
+}
+
+// optional bool did_proceed = 8;
+inline bool ClientSafeBrowsingReportRequest::has_did_proceed() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest::set_has_did_proceed() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_has_did_proceed() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_did_proceed() {
+  did_proceed_ = false;
+  clear_has_did_proceed();
+}
+inline bool ClientSafeBrowsingReportRequest::did_proceed() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.did_proceed)
+  return did_proceed_;
+}
+inline void ClientSafeBrowsingReportRequest::set_did_proceed(bool value) {
+  set_has_did_proceed();
+  did_proceed_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.did_proceed)
+}
+
+// optional bool repeat_visit = 9;
+inline bool ClientSafeBrowsingReportRequest::has_repeat_visit() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest::set_has_repeat_visit() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_has_repeat_visit() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_repeat_visit() {
+  repeat_visit_ = false;
+  clear_has_repeat_visit();
+}
+inline bool ClientSafeBrowsingReportRequest::repeat_visit() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.repeat_visit)
+  return repeat_visit_;
+}
+inline void ClientSafeBrowsingReportRequest::set_repeat_visit(bool value) {
+  set_has_repeat_visit();
+  repeat_visit_ = value;
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.repeat_visit)
+}
+
+// optional bytes token = 15;
+inline bool ClientSafeBrowsingReportRequest::has_token() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void ClientSafeBrowsingReportRequest::set_has_token() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_has_token() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void ClientSafeBrowsingReportRequest::clear_token() {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_->clear();
+  }
+  clear_has_token();
+}
+inline const ::std::string& ClientSafeBrowsingReportRequest::token() const {
+  // @@protoc_insertion_point(field_get:safe_browsing.ClientSafeBrowsingReportRequest.token)
+  return *token_;
+}
+inline void ClientSafeBrowsingReportRequest::set_token(const ::std::string& value) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(value);
+  // @@protoc_insertion_point(field_set:safe_browsing.ClientSafeBrowsingReportRequest.token)
+}
+inline void ClientSafeBrowsingReportRequest::set_token(const char* value) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(value);
+  // @@protoc_insertion_point(field_set_char:safe_browsing.ClientSafeBrowsingReportRequest.token)
+}
+inline void ClientSafeBrowsingReportRequest::set_token(const void* value, size_t size) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:safe_browsing.ClientSafeBrowsingReportRequest.token)
+}
+inline ::std::string* ClientSafeBrowsingReportRequest::mutable_token() {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:safe_browsing.ClientSafeBrowsingReportRequest.token)
+  return token_;
+}
+inline ::std::string* ClientSafeBrowsingReportRequest::release_token() {
+  clear_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = token_;
+    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientSafeBrowsingReportRequest::set_allocated_token(::std::string* token) {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete token_;
+  }
+  if (token) {
+    set_has_token();
+    token_ = token;
+  } else {
+    clear_has_token();
+    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:safe_browsing.ClientSafeBrowsingReportRequest.token)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace safe_browsing
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_chromium_2fchrome_2fcommon_2fsafe_5fbrowsing_2fcsd_2eproto__INCLUDED
diff --git a/toolkit/components/downloads/chromium/chrome/common/safe_browsing/csd.proto b/toolkit/components/downloads/chromium/chrome/common/safe_browsing/csd.proto
new file mode 100644
index 000000000..fc588cc1f
--- /dev/null
+++ b/toolkit/components/downloads/chromium/chrome/common/safe_browsing/csd.proto
@@ -0,0 +1,839 @@
+// 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;
+}
+
+
+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;
+}
+
+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 contained in an archive (e.g., a .zip archive).
+  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;
+
+  message URLChainEntry {
+    enum URLType {
+      DOWNLOAD_URL = 1;
+      DOWNLOAD_REFERRER = 2;
+      LANDING_PAGE = 3;
+      LANDING_REFERRER = 4;
+      CLIENT_REDIRECT = 5;
+      SERVER_REDIRECT = 6;
+    }
+
+    // [required] The url of this Entry.
+    optional string url = 1;
+
+    // Type of URLs, such as download url, download referrer, etc.
+    optional URLType type = 2;
+
+    // IP address corresponding to url.
+    optional string ip_address = 3;
+
+    // Referrer url of this entry.
+    optional string referrer = 4;
+
+    // Main frame URL of referrer.
+    optional string main_frame_referrer = 5;
+
+    // If this URL loads in a different tab/frame from previous one.
+    optional bool is_retargeting = 6;
+
+    // If there is a user gesture attached to this transition.
+    optional bool is_user_initiated = 7;
+
+    optional double timestamp_in_millisec = 8;
+  }  // End of URLChainEntry
+
+  // 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 URLChainEntry url_chain = 36;
+}
+
+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;
+}
+
+// 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;
+      }
+
+      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 BlacklistLoadIncident {
+      optional string path = 1;
+      optional ClientDownloadRequest.Digests digest = 2;
+      optional string version = 3;
+      optional bool blacklist_initialized = 4;
+      optional ClientDownloadRequest.SignatureInfo signature = 5;
+      optional ClientDownloadRequest.ImageHeaders image_headers = 6;
+    }
+    message VariationsSeedSignatureIncident {
+      optional string variations_seed_signature = 1;
+    }
+    message ResourceRequestIncident {
+      enum Type {
+        UNKNOWN = 0;
+        TYPE_PATTERN = 3;
+      }
+      optional bytes digest = 1;
+      optional string origin = 2;
+      optional Type type = 3 [default = UNKNOWN];
+    }
+    message SuspiciousModuleIncident {
+      optional string path = 1;
+      optional ClientDownloadRequest.Digests digest = 2;
+      optional string version = 3;
+      optional ClientDownloadRequest.SignatureInfo signature = 4;
+      optional ClientDownloadRequest.ImageHeaders image_headers = 5;
+    }
+    optional int64 incident_time_msec = 1;
+    optional TrackedPreferenceIncident tracked_preference = 2;
+    optional BinaryIntegrityIncident binary_integrity = 3;
+    optional BlacklistLoadIncident blacklist_load = 4;
+    // Note: skip tag 5 because it was previously used.
+    optional VariationsSeedSignatureIncident variations_seed_signature = 6;
+    optional ResourceRequestIncident resource_request = 7;
+    optional SuspiciousModuleIncident suspicious_module = 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;
+      optional bool 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;
+      optional bool 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: 16
+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;
+    CLIENT_SIDE_PHISHING_URL = 4;
+    CLIENT_SIDE_MALWARE_URL = 5;
+    DANGEROUS_DOWNLOAD_RECOVERY = 6;
+    DANGEROUS_DOWNLOAD_WARNING = 7;
+    DANGEROUS_DOWNLOAD_BY_API = 10;
+  }
+
+  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 reason = 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;
+
+  // 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. This field is only set if its
+  // report type is DANGEROUS_DOWNLOAD_RECOVERY, DANGEROUS_DOWNLOAD_WARNING or
+  // DANGEROUS_DOWNLOAD_BY_API.
+  optional bytes token = 15;
+}
diff --git a/toolkit/components/downloads/generate_csd.sh b/toolkit/components/downloads/generate_csd.sh
new file mode 100755
index 000000000..a322d4c3c
--- /dev/null
+++ b/toolkit/components/downloads/generate_csd.sh
@@ -0,0 +1,33 @@
+#!/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 nsDownloadManager.cpp ]; then
+    echo "You must run this script in the toolkit/components/downloads" >&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/chrome/common/safe_browsing/csd.proto?format=TEXT"
+CSD_PATH="chromium/chrome/common/safe_browsing"
+
+curl "$CSD_PROTO_URL" | base64 --decode > "$CSD_PATH"/csd.proto
+"$PROTOC_PATH" "$CSD_PATH"/csd.proto --cpp_out=.
diff --git a/toolkit/components/downloads/moz.build b/toolkit/components/downloads/moz.build
new file mode 100644
index 000000000..477db0bd6
--- /dev/null
+++ b/toolkit/components/downloads/moz.build
@@ -0,0 +1,74 @@
+# -*- 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', 'Download Manager')
+
+with Files('ApplicationReputation.*'):
+    BUG_COMPONENT = ('Toolkit', 'Safe Browsing')
+
+with Files('chromium/*'):
+    BUG_COMPONENT = ('Toolkit', 'Safe Browsing')
+
+with Files('generate_csd.sh'):
+    BUG_COMPONENT = ('Toolkit', 'Safe Browsing')
+
+with Files('nsIApplicationReputation.idl'):
+    BUG_COMPONENT = ('Toolkit', 'Safe Browsing')
+
+XPCSHELL_TESTS_MANIFESTS += ['test/unit/xpcshell.ini']
+
+XPIDL_SOURCES += [
+    'nsIApplicationReputation.idl',
+    'nsIDownload.idl',
+    'nsIDownloadManager.idl',
+    'nsIDownloadManagerUI.idl',
+    'nsIDownloadProgressListener.idl',
+]
+
+XPIDL_MODULE = 'downloads'
+
+UNIFIED_SOURCES += [
+    'ApplicationReputation.cpp',
+    'chromium/chrome/common/safe_browsing/csd.pb.cc',
+    'nsDownloadManager.cpp'
+]
+
+# SQLFunctions.cpp cannot be built in unified mode because of Windows headers.
+SOURCES += [
+    'SQLFunctions.cpp',
+]
+
+if CONFIG['OS_ARCH'] == 'WINNT':
+    # Can't build unified because we need CreateEvent which some IPC code
+    # included in LoadContext ends up undefining.
+    SOURCES += [
+        'nsDownloadScanner.cpp',
+    ]
+
+# XXX - Until Suite builds off XULRunner we can't guarantee our implementation
+# of nsIDownloadManagerUI overrides toolkit's.
+if not CONFIG['MOZ_SUITE']:
+    EXTRA_COMPONENTS += [
+        'nsDownloadManagerUI.js',
+        'nsDownloadManagerUI.manifest',
+    ]
+
+FINAL_LIBRARY = 'xul'
+
+LOCAL_INCLUDES += [
+    '../protobuf',
+    '/ipc/chromium/src',
+    'chromium'
+]
+
+DEFINES['GOOGLE_PROTOBUF_NO_RTTI'] = True
+DEFINES['GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER'] = True
+
+CXXFLAGS += CONFIG['TK_CFLAGS']
+
+if CONFIG['GNU_CXX']:
+    CXXFLAGS += ['-Wno-shadow']
diff --git a/toolkit/components/downloads/nsDownloadManager.cpp b/toolkit/components/downloads/nsDownloadManager.cpp
new file mode 100644
index 000000000..ab984c5f2
--- /dev/null
+++ b/toolkit/components/downloads/nsDownloadManager.cpp
@@ -0,0 +1,3783 @@
+/* -*- 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 "mozilla/DebugOnly.h"
+#include "mozilla/Unused.h"
+
+#include "mozIStorageService.h"
+#include "nsIAlertsService.h"
+#include "nsIArray.h"
+#include "nsIClassInfoImpl.h"
+#include "nsIDOMWindow.h"
+#include "nsIDownloadHistory.h"
+#include "nsIDownloadManagerUI.h"
+#include "nsIFileURL.h"
+#include "nsIMIMEService.h"
+#include "nsIParentalControlsService.h"
+#include "nsIPrefService.h"
+#include "nsIPrivateBrowsingChannel.h"
+#include "nsIPromptService.h"
+#include "nsIPropertyBag2.h"
+#include "nsIResumableChannel.h"
+#include "nsIWebBrowserPersist.h"
+#include "nsIWindowMediator.h"
+#include "nsILocalFileWin.h"
+#include "nsILoadContext.h"
+#include "nsIXULAppInfo.h"
+#include "nsContentUtils.h"
+
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsArrayEnumerator.h"
+#include "nsCExternalHandlerService.h"
+#include "nsCRTGlue.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsDownloadManager.h"
+#include "nsNetUtil.h"
+#include "nsThreadUtils.h"
+#include "prtime.h"
+
+#include "mozStorageCID.h"
+#include "nsDocShellCID.h"
+#include "nsEmbedCID.h"
+#include "nsToolkitCompsCID.h"
+
+#include "mozilla/net/ReferrerPolicy.h"
+
+#include "SQLFunctions.h"
+
+#include "mozilla/Preferences.h"
+
+#ifdef XP_WIN
+#include <shlobj.h>
+#include "nsWindowsHelpers.h"
+#ifdef DOWNLOAD_SCANNER
+#include "nsDownloadScanner.h"
+#endif
+#endif
+
+#ifdef XP_MACOSX
+#include <CoreFoundation/CoreFoundation.h>
+#endif
+
+#ifdef MOZ_WIDGET_ANDROID
+#include "FennecJNIWrappers.h"
+#endif
+
+#ifdef MOZ_WIDGET_GTK
+#include <gtk/gtk.h>
+#endif
+
+using namespace mozilla;
+using mozilla::downloads::GenerateGUID;
+
+#define DOWNLOAD_MANAGER_BUNDLE "chrome://mozapps/locale/downloads/downloads.properties"
+#define DOWNLOAD_MANAGER_ALERT_ICON "chrome://mozapps/skin/downloads/downloadIcon.png"
+#define PREF_BD_USEJSTRANSFER "browser.download.useJSTransfer"
+#define PREF_BDM_SHOWALERTONCOMPLETE "browser.download.manager.showAlertOnComplete"
+#define PREF_BDM_SHOWALERTINTERVAL "browser.download.manager.showAlertInterval"
+#define PREF_BDM_RETENTION "browser.download.manager.retention"
+#define PREF_BDM_QUITBEHAVIOR "browser.download.manager.quitBehavior"
+#define PREF_BDM_ADDTORECENTDOCS "browser.download.manager.addToRecentDocs"
+#define PREF_BDM_SCANWHENDONE "browser.download.manager.scanWhenDone"
+#define PREF_BDM_RESUMEONWAKEDELAY "browser.download.manager.resumeOnWakeDelay"
+#define PREF_BH_DELETETEMPFILEONEXIT "browser.helperApps.deleteTempFileOnExit"
+
+static const int64_t gUpdateInterval = 400 * PR_USEC_PER_MSEC;
+
+#define DM_SCHEMA_VERSION      9
+#define DM_DB_NAME             NS_LITERAL_STRING("downloads.sqlite")
+#define DM_DB_CORRUPT_FILENAME NS_LITERAL_STRING("downloads.sqlite.corrupt")
+
+#define NS_SYSTEMINFO_CONTRACTID "@mozilla.org/system-info;1"
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsDownloadManager
+
+NS_IMPL_ISUPPORTS(
+  nsDownloadManager
+, nsIDownloadManager
+, nsINavHistoryObserver
+, nsIObserver
+, nsISupportsWeakReference
+)
+
+nsDownloadManager *nsDownloadManager::gDownloadManagerService = nullptr;
+
+nsDownloadManager *
+nsDownloadManager::GetSingleton()
+{
+  if (gDownloadManagerService) {
+    NS_ADDREF(gDownloadManagerService);
+    return gDownloadManagerService;
+  }
+
+  gDownloadManagerService = new nsDownloadManager();
+  if (gDownloadManagerService) {
+#if defined(MOZ_WIDGET_GTK)
+    g_type_init();
+#endif
+    NS_ADDREF(gDownloadManagerService);
+    if (NS_FAILED(gDownloadManagerService->Init()))
+      NS_RELEASE(gDownloadManagerService);
+  }
+
+  return gDownloadManagerService;
+}
+
+nsDownloadManager::~nsDownloadManager()
+{
+#ifdef DOWNLOAD_SCANNER
+  if (mScanner) {
+    delete mScanner;
+    mScanner = nullptr;
+  }
+#endif
+  gDownloadManagerService = nullptr;
+}
+
+nsresult
+nsDownloadManager::ResumeRetry(nsDownload *aDl)
+{
+  // Keep a reference in case we need to cancel the download
+  RefPtr<nsDownload> dl = aDl;
+
+  // Try to resume the active download
+  nsresult rv = dl->Resume();
+
+  // If not, try to retry the download
+  if (NS_FAILED(rv)) {
+    // First cancel the download so it's no longer active
+    rv = dl->Cancel();
+
+    // Then retry it
+    if (NS_SUCCEEDED(rv))
+      rv = dl->Retry();
+  }
+
+  return rv;
+}
+
+nsresult
+nsDownloadManager::PauseAllDownloads(bool aSetResume)
+{
+  nsresult rv = PauseAllDownloads(mCurrentDownloads, aSetResume);
+  nsresult rv2 = PauseAllDownloads(mCurrentPrivateDownloads, aSetResume);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_SUCCESS(rv2, rv2);
+  return NS_OK;
+}
+
+nsresult
+nsDownloadManager::PauseAllDownloads(nsCOMArray<nsDownload>& aDownloads, bool aSetResume)
+{
+  nsresult retVal = NS_OK;
+  for (int32_t i = aDownloads.Count() - 1; i >= 0; --i) {
+    RefPtr<nsDownload> dl = aDownloads[i];
+
+    // Only pause things that need to be paused
+    if (!dl->IsPaused()) {
+      // Set auto-resume before pausing so that it gets into the DB
+      dl->mAutoResume = aSetResume ? nsDownload::AUTO_RESUME :
+                                     nsDownload::DONT_RESUME;
+
+      // Try to pause the download but don't bail now if we fail
+      nsresult rv = dl->Pause();
+      if (NS_FAILED(rv))
+        retVal = rv;
+    }
+  }
+
+  return retVal;
+}
+
+nsresult
+nsDownloadManager::ResumeAllDownloads(bool aResumeAll)
+{
+  nsresult rv = ResumeAllDownloads(mCurrentDownloads, aResumeAll);
+  nsresult rv2 = ResumeAllDownloads(mCurrentPrivateDownloads, aResumeAll);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_SUCCESS(rv2, rv2);
+  return NS_OK;
+}
+
+nsresult
+nsDownloadManager::ResumeAllDownloads(nsCOMArray<nsDownload>& aDownloads, bool aResumeAll)
+{
+  nsresult retVal = NS_OK;
+  for (int32_t i = aDownloads.Count() - 1; i >= 0; --i) {
+    RefPtr<nsDownload> dl = aDownloads[i];
+
+    // If aResumeAll is true, then resume everything; otherwise, check if the
+    // download should auto-resume
+    if (aResumeAll || dl->ShouldAutoResume()) {
+      // Reset auto-resume before retrying so that it gets into the DB through
+      // ResumeRetry's eventual call to SetState. We clear the value now so we
+      // don't accidentally query completed downloads that were previously
+      // auto-resumed (and try to resume them).
+      dl->mAutoResume = nsDownload::DONT_RESUME;
+
+      // Try to resume/retry the download but don't bail now if we fail
+      nsresult rv = ResumeRetry(dl);
+      if (NS_FAILED(rv))
+        retVal = rv;
+    }
+  }
+
+  return retVal;
+}
+
+nsresult
+nsDownloadManager::RemoveAllDownloads()
+{
+  nsresult rv = RemoveAllDownloads(mCurrentDownloads);
+  nsresult rv2 = RemoveAllDownloads(mCurrentPrivateDownloads);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_SUCCESS(rv2, rv2);
+  return NS_OK;
+}
+
+nsresult
+nsDownloadManager::RemoveAllDownloads(nsCOMArray<nsDownload>& aDownloads)
+{
+  nsresult rv = NS_OK;
+  for (int32_t i = aDownloads.Count() - 1; i >= 0; --i) {
+    RefPtr<nsDownload> dl = aDownloads[0];
+
+    nsresult result = NS_OK;
+    if (!dl->mPrivate && dl->IsPaused() && GetQuitBehavior() != QUIT_AND_CANCEL)
+      aDownloads.RemoveObject(dl);
+    else
+      result = dl->Cancel();
+
+    // Track the failure, but don't miss out on other downloads
+    if (NS_FAILED(result))
+      rv = result;
+  }
+
+  return rv;
+}
+
+nsresult
+nsDownloadManager::RemoveDownloadsForURI(mozIStorageStatement* aStatement, nsIURI *aURI)
+{
+  mozStorageStatementScoper scope(aStatement);
+
+  nsAutoCString source;
+  nsresult rv = aURI->GetSpec(source);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = aStatement->BindUTF8StringByName(
+    NS_LITERAL_CSTRING("source"), source);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool hasMore = false;
+  AutoTArray<nsCString, 4> downloads;
+  // Get all the downloads that match the provided URI
+  while (NS_SUCCEEDED(aStatement->ExecuteStep(&hasMore)) &&
+         hasMore) {
+    nsAutoCString downloadGuid;
+    rv = aStatement->GetUTF8String(0, downloadGuid);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    downloads.AppendElement(downloadGuid);
+  }
+
+  // Remove each download ignoring any failure so we reach other downloads
+  for (int32_t i = downloads.Length(); --i >= 0; )
+    (void)RemoveDownload(downloads[i]);
+
+  return NS_OK;
+}
+
+void // static
+nsDownloadManager::ResumeOnWakeCallback(nsITimer *aTimer, void *aClosure)
+{
+  // Resume the downloads that were set to autoResume
+  nsDownloadManager *dlMgr = static_cast<nsDownloadManager *>(aClosure);
+  (void)dlMgr->ResumeAllDownloads(false);
+}
+
+already_AddRefed<mozIStorageConnection>
+nsDownloadManager::GetFileDBConnection(nsIFile *dbFile) const
+{
+  NS_ASSERTION(dbFile, "GetFileDBConnection called with an invalid nsIFile");
+
+  nsCOMPtr<mozIStorageService> storage =
+    do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID);
+  NS_ENSURE_TRUE(storage, nullptr);
+
+  nsCOMPtr<mozIStorageConnection> conn;
+  nsresult rv = storage->OpenDatabase(dbFile, getter_AddRefs(conn));
+  if (rv == NS_ERROR_FILE_CORRUPTED) {
+    // delete and try again, since we don't care so much about losing a user's
+    // download history
+    rv = dbFile->Remove(false);
+    NS_ENSURE_SUCCESS(rv, nullptr);
+    rv = storage->OpenDatabase(dbFile, getter_AddRefs(conn));
+  }
+  NS_ENSURE_SUCCESS(rv, nullptr);
+
+  return conn.forget();
+}
+
+already_AddRefed<mozIStorageConnection>
+nsDownloadManager::GetPrivateDBConnection() const
+{
+  nsCOMPtr<mozIStorageService> storage =
+    do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID);
+  NS_ENSURE_TRUE(storage, nullptr);
+
+  nsCOMPtr<mozIStorageConnection> conn;
+  nsresult rv = storage->OpenSpecialDatabase("memory", getter_AddRefs(conn));
+  NS_ENSURE_SUCCESS(rv, nullptr);
+
+  return conn.forget();
+}
+
+void
+nsDownloadManager::CloseAllDBs()
+{
+  CloseDB(mDBConn, mUpdateDownloadStatement, mGetIdsForURIStatement);
+  CloseDB(mPrivateDBConn, mUpdatePrivateDownloadStatement, mGetPrivateIdsForURIStatement);
+}
+
+void
+nsDownloadManager::CloseDB(mozIStorageConnection* aDBConn,
+                           mozIStorageStatement* aUpdateStmt,
+                           mozIStorageStatement* aGetIdsStmt)
+{
+  DebugOnly<nsresult> rv = aGetIdsStmt->Finalize();
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+  rv = aUpdateStmt->Finalize();
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+  rv = aDBConn->AsyncClose(nullptr);
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+}
+
+static nsresult
+InitSQLFunctions(mozIStorageConnection* aDBConn)
+{
+  nsresult rv = mozilla::downloads::GenerateGUIDFunction::create(aDBConn);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return NS_OK;
+}
+
+nsresult
+nsDownloadManager::InitPrivateDB()
+{
+  bool ready = false;
+  if (mPrivateDBConn && NS_SUCCEEDED(mPrivateDBConn->GetConnectionReady(&ready)) && ready)
+    CloseDB(mPrivateDBConn, mUpdatePrivateDownloadStatement, mGetPrivateIdsForURIStatement);
+  mPrivateDBConn = GetPrivateDBConnection();
+  if (!mPrivateDBConn)
+    return NS_ERROR_NOT_AVAILABLE;
+
+  nsresult rv = InitSQLFunctions(mPrivateDBConn);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = CreateTable(mPrivateDBConn);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = InitStatements(mPrivateDBConn, getter_AddRefs(mUpdatePrivateDownloadStatement),
+                      getter_AddRefs(mGetPrivateIdsForURIStatement));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return NS_OK;
+}
+
+nsresult
+nsDownloadManager::InitFileDB()
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIFile> dbFile;
+  rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
+                              getter_AddRefs(dbFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = dbFile->Append(DM_DB_NAME);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool ready = false;
+  if (mDBConn && NS_SUCCEEDED(mDBConn->GetConnectionReady(&ready)) && ready)
+    CloseDB(mDBConn, mUpdateDownloadStatement, mGetIdsForURIStatement);
+  mDBConn = GetFileDBConnection(dbFile);
+  NS_ENSURE_TRUE(mDBConn, NS_ERROR_NOT_AVAILABLE);
+
+  rv = InitSQLFunctions(mDBConn);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool tableExists;
+  rv = mDBConn->TableExists(NS_LITERAL_CSTRING("moz_downloads"), &tableExists);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!tableExists) {
+    rv = CreateTable(mDBConn);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // We're done with the initialization now and can skip the remaining
+    // upgrading logic.
+    return NS_OK;
+  }
+
+  // Checking the database schema now
+  int32_t schemaVersion;
+  rv = mDBConn->GetSchemaVersion(&schemaVersion);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Changing the database?  Be sure to do these two things!
+  // 1) Increment DM_SCHEMA_VERSION
+  // 2) Implement the proper downgrade/upgrade code for the current version
+
+  switch (schemaVersion) {
+  // Upgrading
+  // Every time you increment the database schema, you need to implement
+  // the upgrading code from the previous version to the new one.
+  // Also, don't forget to make a unit test to test your upgrading code!
+  case 1: // Drop a column (iconURL) from the database (bug 385875)
+    {
+      // Safely wrap this in a transaction so we don't hose the whole DB
+      mozStorageTransaction safeTransaction(mDBConn, true);
+
+      // Create a temporary table that will store the existing records
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "CREATE TEMPORARY TABLE moz_downloads_backup ("
+          "id INTEGER PRIMARY KEY, "
+          "name TEXT, "
+          "source TEXT, "
+          "target TEXT, "
+          "startTime INTEGER, "
+          "endTime INTEGER, "
+          "state INTEGER"
+        ")"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Insert into a temporary table
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "INSERT INTO moz_downloads_backup "
+        "SELECT id, name, source, target, startTime, endTime, state "
+        "FROM moz_downloads"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Drop the old table
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "DROP TABLE moz_downloads"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Now recreate it with this schema version
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "CREATE TABLE moz_downloads ("
+          "id INTEGER PRIMARY KEY, "
+          "name TEXT, "
+          "source TEXT, "
+          "target TEXT, "
+          "startTime INTEGER, "
+          "endTime INTEGER, "
+          "state INTEGER"
+        ")"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Insert the data back into it
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "INSERT INTO moz_downloads "
+        "SELECT id, name, source, target, startTime, endTime, state "
+        "FROM moz_downloads_backup"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // And drop our temporary table
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "DROP TABLE moz_downloads_backup"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Finally, update the schemaVersion variable and the database schema
+      schemaVersion = 2;
+      rv = mDBConn->SetSchemaVersion(schemaVersion);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    // Fallthrough to the next upgrade
+    MOZ_FALLTHROUGH;
+
+  case 2: // Add referrer column to the database
+    {
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "ALTER TABLE moz_downloads "
+        "ADD COLUMN referrer TEXT"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Finally, update the schemaVersion variable and the database schema
+      schemaVersion = 3;
+      rv = mDBConn->SetSchemaVersion(schemaVersion);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    // Fallthrough to the next upgrade
+    MOZ_FALLTHROUGH;
+
+  case 3: // This version adds a column to the database (entityID)
+    {
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "ALTER TABLE moz_downloads "
+        "ADD COLUMN entityID TEXT"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Finally, update the schemaVersion variable and the database schema
+      schemaVersion = 4;
+      rv = mDBConn->SetSchemaVersion(schemaVersion);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    // Fallthrough to the next upgrade
+    MOZ_FALLTHROUGH;
+
+  case 4: // This version adds a column to the database (tempPath)
+    {
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "ALTER TABLE moz_downloads "
+        "ADD COLUMN tempPath TEXT"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Finally, update the schemaVersion variable and the database schema
+      schemaVersion = 5;
+      rv = mDBConn->SetSchemaVersion(schemaVersion);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    // Fallthrough to the next upgrade
+    MOZ_FALLTHROUGH;
+
+  case 5: // This version adds two columns for tracking transfer progress
+    {
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "ALTER TABLE moz_downloads "
+        "ADD COLUMN currBytes INTEGER NOT NULL DEFAULT 0"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "ALTER TABLE moz_downloads "
+        "ADD COLUMN maxBytes INTEGER NOT NULL DEFAULT -1"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Finally, update the schemaVersion variable and the database schema
+      schemaVersion = 6;
+      rv = mDBConn->SetSchemaVersion(schemaVersion);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    // Fallthrough to the next upgrade
+    MOZ_FALLTHROUGH;
+
+  case 6: // This version adds three columns to DB (MIME type related info)
+    {
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "ALTER TABLE moz_downloads "
+        "ADD COLUMN mimeType TEXT"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "ALTER TABLE moz_downloads "
+        "ADD COLUMN preferredApplication TEXT"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "ALTER TABLE moz_downloads "
+        "ADD COLUMN preferredAction INTEGER NOT NULL DEFAULT 0"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Finally, update the schemaVersion variable and the database schema
+      schemaVersion = 7;
+      rv = mDBConn->SetSchemaVersion(schemaVersion);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    // Fallthrough to next upgrade
+    MOZ_FALLTHROUGH;
+
+  case 7: // This version adds a column to remember to auto-resume downloads
+    {
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "ALTER TABLE moz_downloads "
+        "ADD COLUMN autoResume INTEGER NOT NULL DEFAULT 0"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Finally, update the schemaVersion variable and the database schema
+      schemaVersion = 8;
+      rv = mDBConn->SetSchemaVersion(schemaVersion);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    // Fallthrough to the next upgrade
+    MOZ_FALLTHROUGH;
+
+    // Warning: schema versions >=8 must take into account that they can
+    // be operating on schemas from unknown, future versions that have
+    // been downgraded. Operations such as adding columns may fail,
+    // since the column may already exist.
+
+  case 8: // This version adds a column for GUIDs
+    {
+      bool exists;
+      rv = mDBConn->IndexExists(NS_LITERAL_CSTRING("moz_downloads_guid_uniqueindex"),
+                                &exists);
+      NS_ENSURE_SUCCESS(rv, rv);
+      if (!exists) {
+        rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+          "ALTER TABLE moz_downloads ADD COLUMN guid TEXT"));
+        NS_ENSURE_SUCCESS(rv, rv);
+        rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+          "CREATE UNIQUE INDEX moz_downloads_guid_uniqueindex ON moz_downloads (guid)"));
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "UPDATE moz_downloads SET guid = GENERATE_GUID() WHERE guid ISNULL"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Finally, update the database schema
+      schemaVersion = 9;
+      rv = mDBConn->SetSchemaVersion(schemaVersion);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    // Fallthrough to the next upgrade
+
+  // Extra sanity checking for developers
+#ifndef DEBUG
+    MOZ_FALLTHROUGH;
+  case DM_SCHEMA_VERSION:
+#endif
+    break;
+
+  case 0:
+    {
+      NS_WARNING("Could not get download database's schema version!");
+
+      // The table may still be usable - someone may have just messed with the
+      // schema version, so let's just treat this like a downgrade and verify
+      // that the needed columns are there.  If they aren't there, we'll drop
+      // the table anyway.
+      rv = mDBConn->SetSchemaVersion(DM_SCHEMA_VERSION);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    // Fallthrough to downgrade check
+    MOZ_FALLTHROUGH;
+
+  // Downgrading
+  // If columns have been added to the table, we can still use the ones we
+  // understand safely.  If columns have been deleted or alterd, we just
+  // drop the table and start from scratch.  If you change how a column
+  // should be interpreted, make sure you also change its name so this
+  // check will catch it.
+  default:
+    {
+      nsCOMPtr<mozIStorageStatement> stmt;
+      rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(
+        "SELECT id, name, source, target, tempPath, startTime, endTime, state, "
+               "referrer, entityID, currBytes, maxBytes, mimeType, "
+               "preferredApplication, preferredAction, autoResume, guid "
+        "FROM moz_downloads"), getter_AddRefs(stmt));
+      if (NS_SUCCEEDED(rv)) {
+        // We have a database that contains all of the elements that make up
+        // the latest known schema. Reset the version to force an upgrade
+        // path if this downgraded database is used in a later version.
+        mDBConn->SetSchemaVersion(DM_SCHEMA_VERSION);
+        break;
+      }
+
+      // if the statement fails, that means all the columns were not there.
+      // First we backup the database
+      nsCOMPtr<mozIStorageService> storage =
+        do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID);
+      NS_ENSURE_TRUE(storage, NS_ERROR_NOT_AVAILABLE);
+      nsCOMPtr<nsIFile> backup;
+      rv = storage->BackupDatabaseFile(dbFile, DM_DB_CORRUPT_FILENAME, nullptr,
+                                       getter_AddRefs(backup));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Then we dump it
+      rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+        "DROP TABLE moz_downloads"));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = CreateTable(mDBConn);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    break;
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsDownloadManager::CreateTable(mozIStorageConnection* aDBConn)
+{
+  nsresult rv = aDBConn->SetSchemaVersion(DM_SCHEMA_VERSION);
+  if (NS_FAILED(rv)) return rv;
+
+  rv = aDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+    "CREATE TABLE moz_downloads ("
+      "id INTEGER PRIMARY KEY, "
+      "name TEXT, "
+      "source TEXT, "
+      "target TEXT, "
+      "tempPath TEXT, "
+      "startTime INTEGER, "
+      "endTime INTEGER, "
+      "state INTEGER, "
+      "referrer TEXT, "
+      "entityID TEXT, "
+      "currBytes INTEGER NOT NULL DEFAULT 0, "
+      "maxBytes INTEGER NOT NULL DEFAULT -1, "
+      "mimeType TEXT, "
+      "preferredApplication TEXT, "
+      "preferredAction INTEGER NOT NULL DEFAULT 0, "
+      "autoResume INTEGER NOT NULL DEFAULT 0, "
+      "guid TEXT"
+    ")"));
+  if (NS_FAILED(rv)) return rv;
+
+  rv = aDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+    "CREATE UNIQUE INDEX moz_downloads_guid_uniqueindex "
+      "ON moz_downloads(guid)"));
+  return rv;
+}
+
+nsresult
+nsDownloadManager::RestoreDatabaseState()
+{
+  // Restore downloads that were in a scanning state.  We can assume that they
+  // have been dealt with by the virus scanner
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(
+    "UPDATE moz_downloads "
+    "SET state = :state "
+    "WHERE state = :state_cond"), getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("state"), nsIDownloadManager::DOWNLOAD_FINISHED);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("state_cond"), nsIDownloadManager::DOWNLOAD_SCANNING);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->Execute();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Convert supposedly-active downloads into downloads that should auto-resume
+  rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(
+    "UPDATE moz_downloads "
+    "SET autoResume = :autoResume "
+    "WHERE state = :notStarted "
+      "OR state = :queued "
+      "OR state = :downloading"), getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("autoResume"), nsDownload::AUTO_RESUME);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("notStarted"), nsIDownloadManager::DOWNLOAD_NOTSTARTED);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("queued"), nsIDownloadManager::DOWNLOAD_QUEUED);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("downloading"), nsIDownloadManager::DOWNLOAD_DOWNLOADING);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->Execute();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Switch any download that is supposed to automatically resume and is in a
+  // finished state to *not* automatically resume.  See Bug 409179 for details.
+  rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(
+    "UPDATE moz_downloads "
+    "SET autoResume = :autoResume "
+    "WHERE state = :state "
+      "AND autoResume = :autoResume_cond"),
+    getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("autoResume"), nsDownload::DONT_RESUME);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("state"), nsIDownloadManager::DOWNLOAD_FINISHED);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("autoResume_cond"), nsDownload::AUTO_RESUME);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->Execute();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+nsresult
+nsDownloadManager::RestoreActiveDownloads()
+{
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(
+    "SELECT id "
+    "FROM moz_downloads "
+    "WHERE (state = :state AND LENGTH(entityID) > 0) "
+      "OR autoResume != :autoResume"), getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("state"), nsIDownloadManager::DOWNLOAD_PAUSED);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("autoResume"), nsDownload::DONT_RESUME);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsresult retVal = NS_OK;
+  bool hasResults;
+  while (NS_SUCCEEDED(stmt->ExecuteStep(&hasResults)) && hasResults) {
+    RefPtr<nsDownload> dl;
+    // Keep trying to add even if we fail one, but make sure to return failure.
+    // Additionally, be careful to not call anything that tries to change the
+    // database because we're iterating over a live statement.
+    if (NS_FAILED(GetDownloadFromDB(stmt->AsInt32(0), getter_AddRefs(dl))) ||
+        NS_FAILED(AddToCurrentDownloads(dl)))
+      retVal = NS_ERROR_FAILURE;
+  }
+
+  // Try to resume only the downloads that should auto-resume
+  rv = ResumeAllDownloads(false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return retVal;
+}
+
+int64_t
+nsDownloadManager::AddDownloadToDB(const nsAString &aName,
+                                   const nsACString &aSource,
+                                   const nsACString &aTarget,
+                                   const nsAString &aTempPath,
+                                   int64_t aStartTime,
+                                   int64_t aEndTime,
+                                   const nsACString &aMimeType,
+                                   const nsACString &aPreferredApp,
+                                   nsHandlerInfoAction aPreferredAction,
+                                   bool aPrivate,
+                                   nsACString& aNewGUID)
+{
+  mozIStorageConnection* dbConn = aPrivate ? mPrivateDBConn : mDBConn;
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = dbConn->CreateStatement(NS_LITERAL_CSTRING(
+    "INSERT INTO moz_downloads "
+    "(name, source, target, tempPath, startTime, endTime, state, "
+     "mimeType, preferredApplication, preferredAction, guid) VALUES "
+    "(:name, :source, :target, :tempPath, :startTime, :endTime, :state, "
+     ":mimeType, :preferredApplication, :preferredAction, :guid)"),
+    getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  rv = stmt->BindStringByName(NS_LITERAL_CSTRING("name"), aName);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("source"), aSource);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("target"), aTarget);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  rv = stmt->BindStringByName(NS_LITERAL_CSTRING("tempPath"), aTempPath);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("startTime"), aStartTime);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("endTime"), aEndTime);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("state"), nsIDownloadManager::DOWNLOAD_NOTSTARTED);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("mimeType"), aMimeType);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("preferredApplication"), aPreferredApp);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("preferredAction"), aPreferredAction);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  nsAutoCString guid;
+  rv = GenerateGUID(guid);
+  NS_ENSURE_SUCCESS(rv, 0);
+  rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), guid);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  bool hasMore;
+  rv = stmt->ExecuteStep(&hasMore); // we want to keep our lock
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  int64_t id = 0;
+  rv = dbConn->GetLastInsertRowID(&id);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  aNewGUID = guid;
+
+  // lock on DB from statement will be released once we return
+  return id;
+}
+
+nsresult
+nsDownloadManager::InitDB()
+{
+  nsresult rv = InitPrivateDB();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = InitFileDB();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = InitStatements(mDBConn, getter_AddRefs(mUpdateDownloadStatement),
+                      getter_AddRefs(mGetIdsForURIStatement));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return NS_OK;
+}
+
+nsresult
+nsDownloadManager::InitStatements(mozIStorageConnection* aDBConn,
+                                  mozIStorageStatement** aUpdateStatement,
+                                  mozIStorageStatement** aGetIdsStatement)
+{
+  nsresult rv = aDBConn->CreateStatement(NS_LITERAL_CSTRING(
+    "UPDATE moz_downloads "
+    "SET tempPath = :tempPath, startTime = :startTime, endTime = :endTime, "
+      "state = :state, referrer = :referrer, entityID = :entityID, "
+      "currBytes = :currBytes, maxBytes = :maxBytes, autoResume = :autoResume "
+    "WHERE id = :id"), aUpdateStatement);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = aDBConn->CreateStatement(NS_LITERAL_CSTRING(
+    "SELECT guid "
+    "FROM moz_downloads "
+    "WHERE source = :source"), aGetIdsStatement);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+nsresult
+nsDownloadManager::Init()
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIStringBundleService> bundleService =
+    mozilla::services::GetStringBundleService();
+  if (!bundleService)
+    return NS_ERROR_FAILURE;
+
+  rv = bundleService->CreateBundle(DOWNLOAD_MANAGER_BUNDLE,
+                                   getter_AddRefs(mBundle));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+#if !defined(MOZ_JSDOWNLOADS)
+  // When MOZ_JSDOWNLOADS is undefined, we still check the preference that can
+  // be used to enable the JavaScript API during the migration process.
+  mUseJSTransfer = Preferences::GetBool(PREF_BD_USEJSTRANSFER, false);
+#else
+  mUseJSTransfer = true;
+#endif
+
+  if (mUseJSTransfer)
+    return NS_OK;
+
+  // Clean up any old downloads.rdf files from before Firefox 3
+  {
+    nsCOMPtr<nsIFile> oldDownloadsFile;
+    bool fileExists;
+    if (NS_SUCCEEDED(NS_GetSpecialDirectory(NS_APP_DOWNLOADS_50_FILE,
+          getter_AddRefs(oldDownloadsFile))) &&
+        NS_SUCCEEDED(oldDownloadsFile->Exists(&fileExists)) &&
+        fileExists) {
+      (void)oldDownloadsFile->Remove(false);
+    }
+  }
+
+  mObserverService = mozilla::services::GetObserverService();
+  if (!mObserverService)
+    return NS_ERROR_FAILURE;
+
+  rv = InitDB();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+#ifdef DOWNLOAD_SCANNER
+  mScanner = new nsDownloadScanner();
+  if (!mScanner)
+    return NS_ERROR_OUT_OF_MEMORY;
+  rv = mScanner->Init();
+  if (NS_FAILED(rv)) {
+    delete mScanner;
+    mScanner = nullptr;
+  }
+#endif
+
+  // Do things *after* initializing various download manager properties such as
+  // restoring downloads to a consistent state
+  rv = RestoreDatabaseState();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = RestoreActiveDownloads();
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "Failed to restore all active downloads");
+
+  nsCOMPtr<nsINavHistoryService> history =
+    do_GetService(NS_NAVHISTORYSERVICE_CONTRACTID);
+
+  (void)mObserverService->NotifyObservers(
+                                static_cast<nsIDownloadManager *>(this),
+                                "download-manager-initialized",
+                                nullptr);
+
+  // The following AddObserver calls must be the last lines in this function,
+  // because otherwise, this function may fail (and thus, this object would be not
+  // completely initialized), but the observerservice would still keep a reference
+  // to us and notify us about shutdown, which may cause crashes.
+  // failure to add an observer is not critical
+  (void)mObserverService->AddObserver(this, "quit-application", true);
+  (void)mObserverService->AddObserver(this, "quit-application-requested", true);
+  (void)mObserverService->AddObserver(this, "offline-requested", true);
+  (void)mObserverService->AddObserver(this, "sleep_notification", true);
+  (void)mObserverService->AddObserver(this, "wake_notification", true);
+  (void)mObserverService->AddObserver(this, "suspend_process_notification", true);
+  (void)mObserverService->AddObserver(this, "resume_process_notification", true);
+  (void)mObserverService->AddObserver(this, "profile-before-change", true);
+  (void)mObserverService->AddObserver(this, NS_IOSERVICE_GOING_OFFLINE_TOPIC, true);
+  (void)mObserverService->AddObserver(this, NS_IOSERVICE_OFFLINE_STATUS_TOPIC, true);
+  (void)mObserverService->AddObserver(this, "last-pb-context-exited", true);
+  (void)mObserverService->AddObserver(this, "last-pb-context-exiting", true);
+
+  if (history)
+    (void)history->AddObserver(this, true);
+
+  return NS_OK;
+}
+
+int32_t
+nsDownloadManager::GetRetentionBehavior()
+{
+  // We use 0 as the default, which is "remove when done"
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> pref = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  int32_t val;
+  rv = pref->GetIntPref(PREF_BDM_RETENTION, &val);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  // Allow the Downloads Panel to change the retention behavior.  We do this to
+  // allow proper migration to the new feature when using the same profile on
+  // multiple versions of the product (bug 697678).  Implementation note: in
+  // order to allow observers to change the retention value, we have to pass an
+  // object in the aSubject parameter, we cannot use aData for that.
+  nsCOMPtr<nsISupportsPRInt32> retentionBehavior =
+    do_CreateInstance(NS_SUPPORTS_PRINT32_CONTRACTID);
+  retentionBehavior->SetData(val);
+  (void)mObserverService->NotifyObservers(retentionBehavior,
+                                          "download-manager-change-retention",
+                                          nullptr);
+  retentionBehavior->GetData(&val);
+
+  return val;
+}
+
+enum nsDownloadManager::QuitBehavior
+nsDownloadManager::GetQuitBehavior()
+{
+  // We use 0 as the default, which is "remember and resume the download"
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> pref = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, QUIT_AND_RESUME);
+
+  int32_t val;
+  rv = pref->GetIntPref(PREF_BDM_QUITBEHAVIOR, &val);
+  NS_ENSURE_SUCCESS(rv, QUIT_AND_RESUME);
+
+  switch (val) {
+    case 1:
+      return QUIT_AND_PAUSE;
+    case 2:
+      return QUIT_AND_CANCEL;
+    default:
+      return QUIT_AND_RESUME;
+  }
+}
+
+// Using a globally-unique GUID, search all databases (both private and public).
+// A return value of NS_ERROR_NOT_AVAILABLE means no download with the given GUID
+// could be found, either private or public.
+
+nsresult
+nsDownloadManager::GetDownloadFromDB(const nsACString& aGUID, nsDownload **retVal)
+{
+  MOZ_ASSERT(!FindDownload(aGUID),
+             "If it is a current download, you should not call this method!");
+
+  NS_NAMED_LITERAL_CSTRING(query,
+    "SELECT id, state, startTime, source, target, tempPath, name, referrer, "
+           "entityID, currBytes, maxBytes, mimeType, preferredAction, "
+           "preferredApplication, autoResume, guid "
+    "FROM moz_downloads "
+    "WHERE guid = :guid");
+  // First, let's query the database and see if it even exists
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = mDBConn->CreateStatement(query, getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), aGUID);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = GetDownloadFromDB(mDBConn, stmt, retVal);
+
+  // If the download cannot be found in the public database, try again
+  // in the private one. Otherwise, return whatever successful result
+  // or failure obtained from the public database.
+  if (rv == NS_ERROR_NOT_AVAILABLE) {
+    rv = mPrivateDBConn->CreateStatement(query, getter_AddRefs(stmt));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), aGUID);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = GetDownloadFromDB(mPrivateDBConn, stmt, retVal);
+
+    // Only if it still cannot be found do we report the failure.
+    if (rv == NS_ERROR_NOT_AVAILABLE) {
+      *retVal = nullptr;
+    }
+  }
+  return rv;
+}
+
+nsresult
+nsDownloadManager::GetDownloadFromDB(uint32_t aID, nsDownload **retVal)
+{
+  NS_WARNING("Using integer IDs without compat mode enabled");
+
+  MOZ_ASSERT(!FindDownload(aID),
+             "If it is a current download, you should not call this method!");
+
+  // First, let's query the database and see if it even exists
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(
+    "SELECT id, state, startTime, source, target, tempPath, name, referrer, "
+           "entityID, currBytes, maxBytes, mimeType, preferredAction, "
+           "preferredApplication, autoResume, guid "
+    "FROM moz_downloads "
+    "WHERE id = :id"), getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("id"), aID);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return GetDownloadFromDB(mDBConn, stmt, retVal);
+}
+
+nsresult
+nsDownloadManager::GetDownloadFromDB(mozIStorageConnection* aDBConn,
+                                     mozIStorageStatement* stmt,
+                                     nsDownload **retVal)
+{
+  bool hasResults = false;
+  nsresult rv = stmt->ExecuteStep(&hasResults);
+  if (NS_FAILED(rv) || !hasResults)
+    return NS_ERROR_NOT_AVAILABLE;
+
+  // We have a download, so lets create it
+  RefPtr<nsDownload> dl = new nsDownload();
+  if (!dl)
+    return NS_ERROR_OUT_OF_MEMORY;
+  dl->mPrivate = aDBConn == mPrivateDBConn;
+
+  dl->mDownloadManager = this;
+
+  int32_t i = 0;
+  // Setting all properties of the download now
+  dl->mCancelable = nullptr;
+  dl->mID = stmt->AsInt64(i++);
+  dl->mDownloadState = stmt->AsInt32(i++);
+  dl->mStartTime = stmt->AsInt64(i++);
+
+  nsCString source;
+  stmt->GetUTF8String(i++, source);
+  rv = NS_NewURI(getter_AddRefs(dl->mSource), source);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString target;
+  stmt->GetUTF8String(i++, target);
+  rv = NS_NewURI(getter_AddRefs(dl->mTarget), target);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsString tempPath;
+  stmt->GetString(i++, tempPath);
+  if (!tempPath.IsEmpty()) {
+    rv = NS_NewLocalFile(tempPath, true, getter_AddRefs(dl->mTempFile));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  stmt->GetString(i++, dl->mDisplayName);
+
+  nsCString referrer;
+  rv = stmt->GetUTF8String(i++, referrer);
+  if (NS_SUCCEEDED(rv) && !referrer.IsEmpty()) {
+    rv = NS_NewURI(getter_AddRefs(dl->mReferrer), referrer);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  rv = stmt->GetUTF8String(i++, dl->mEntityID);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int64_t currBytes = stmt->AsInt64(i++);
+  int64_t maxBytes = stmt->AsInt64(i++);
+  dl->SetProgressBytes(currBytes, maxBytes);
+
+  // Build mMIMEInfo only if the mimeType in DB is not empty
+  nsAutoCString mimeType;
+  rv = stmt->GetUTF8String(i++, mimeType);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!mimeType.IsEmpty()) {
+    nsCOMPtr<nsIMIMEService> mimeService =
+      do_GetService(NS_MIMESERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = mimeService->GetFromTypeAndExtension(mimeType, EmptyCString(),
+                                              getter_AddRefs(dl->mMIMEInfo));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsHandlerInfoAction action = stmt->AsInt32(i++);
+    rv = dl->mMIMEInfo->SetPreferredAction(action);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoCString persistentDescriptor;
+    rv = stmt->GetUTF8String(i++, persistentDescriptor);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (!persistentDescriptor.IsEmpty()) {
+      nsCOMPtr<nsILocalHandlerApp> handler =
+        do_CreateInstance(NS_LOCALHANDLERAPP_CONTRACTID, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCOMPtr<nsIFile> localExecutable;
+      rv = NS_NewNativeLocalFile(EmptyCString(), false,
+                                 getter_AddRefs(localExecutable));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = localExecutable->SetPersistentDescriptor(persistentDescriptor);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = handler->SetExecutable(localExecutable);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = dl->mMIMEInfo->SetPreferredApplicationHandler(handler);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  } else {
+    // Compensate for the i++s skipped in the true block
+    i += 2;
+  }
+
+  dl->mAutoResume =
+    static_cast<enum nsDownload::AutoResume>(stmt->AsInt32(i++));
+
+  rv = stmt->GetUTF8String(i++, dl->mGUID);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Handle situations where we load a download from a database that has been
+  // used in an older version and not gone through the upgrade path (ie. it
+  // contains empty GUID entries).
+  if (dl->mGUID.IsEmpty()) {
+    rv = GenerateGUID(dl->mGUID);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<mozIStorageStatement> updateStmt;
+    rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(
+                                    "UPDATE moz_downloads SET guid = :guid "
+                                    "WHERE id = :id"),
+                                  getter_AddRefs(updateStmt));
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = updateStmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), dl->mGUID);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = updateStmt->BindInt64ByName(NS_LITERAL_CSTRING("id"), dl->mID);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = updateStmt->Execute();
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Addrefing and returning
+  dl.forget(retVal);
+  return NS_OK;
+}
+
+nsresult
+nsDownloadManager::AddToCurrentDownloads(nsDownload *aDl)
+{
+  nsCOMArray<nsDownload>& currentDownloads =
+    aDl->mPrivate ? mCurrentPrivateDownloads : mCurrentDownloads;
+  if (!currentDownloads.AppendObject(aDl))
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  aDl->mDownloadManager = this;
+  return NS_OK;
+}
+
+void
+nsDownloadManager::SendEvent(nsDownload *aDownload, const char *aTopic)
+{
+  (void)mObserverService->NotifyObservers(aDownload, aTopic, nullptr);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsIDownloadManager
+
+NS_IMETHODIMP
+nsDownloadManager::GetActivePrivateDownloadCount(int32_t* aResult)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  *aResult = mCurrentPrivateDownloads.Count();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::GetActiveDownloadCount(int32_t *aResult)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  *aResult = mCurrentDownloads.Count();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::GetActiveDownloads(nsISimpleEnumerator **aResult)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  return NS_NewArrayEnumerator(aResult, mCurrentDownloads);
+}
+
+NS_IMETHODIMP
+nsDownloadManager::GetActivePrivateDownloads(nsISimpleEnumerator **aResult)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  return NS_NewArrayEnumerator(aResult, mCurrentPrivateDownloads);
+}
+
+/**
+ * For platforms where helper apps use the downloads directory (i.e. mobile),
+ * this should be kept in sync with nsExternalHelperAppService.cpp
+ */
+NS_IMETHODIMP
+nsDownloadManager::GetDefaultDownloadsDirectory(nsIFile **aResult)
+{
+  nsCOMPtr<nsIFile> downloadDir;
+
+  nsresult rv;
+  nsCOMPtr<nsIProperties> dirService =
+     do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // OSX 10.4:
+  // Desktop
+  // OSX 10.5:
+  // User download directory
+  // Vista:
+  // Downloads
+  // XP/2K:
+  // My Documents/Downloads
+  // Linux:
+  // XDG user dir spec, with a fallback to Home/Downloads
+
+  nsXPIDLString folderName;
+  mBundle->GetStringFromName(u"downloadsFolder",
+                             getter_Copies(folderName));
+
+#if defined (XP_MACOSX)
+  rv = dirService->Get(NS_OSX_DEFAULT_DOWNLOAD_DIR,
+                       NS_GET_IID(nsIFile),
+                       getter_AddRefs(downloadDir));
+  NS_ENSURE_SUCCESS(rv, rv);
+#elif defined(XP_WIN)
+  rv = dirService->Get(NS_WIN_DEFAULT_DOWNLOAD_DIR,
+                       NS_GET_IID(nsIFile),
+                       getter_AddRefs(downloadDir));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Check the os version
+  nsCOMPtr<nsIPropertyBag2> infoService =
+     do_GetService(NS_SYSTEMINFO_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t version;
+  NS_NAMED_LITERAL_STRING(osVersion, "version");
+  rv = infoService->GetPropertyAsInt32(osVersion, &version);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (version < 6) { // XP/2K
+    // First get "My Documents"
+    rv = dirService->Get(NS_WIN_PERSONAL_DIR,
+                         NS_GET_IID(nsIFile),
+                         getter_AddRefs(downloadDir));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = downloadDir->Append(folderName);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // This could be the first time we are creating the downloads folder in My
+    // Documents, so make sure it exists.
+    bool exists;
+    rv = downloadDir->Exists(&exists);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!exists) {
+      rv = downloadDir->Create(nsIFile::DIRECTORY_TYPE, 0755);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+#elif defined(XP_UNIX)
+#if defined(MOZ_WIDGET_ANDROID)
+    // Android doesn't have a $HOME directory, and by default we only have
+    // write access to /data/data/org.mozilla.{$APP} and /sdcard
+    char* downloadDirPath = getenv("DOWNLOADS_DIRECTORY");
+    if (downloadDirPath) {
+      rv = NS_NewNativeLocalFile(nsDependentCString(downloadDirPath),
+                                 true, getter_AddRefs(downloadDir));
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    else {
+      rv = NS_ERROR_FAILURE;
+    }
+#else
+  rv = dirService->Get(NS_UNIX_DEFAULT_DOWNLOAD_DIR,
+                       NS_GET_IID(nsIFile),
+                       getter_AddRefs(downloadDir));
+  // fallback to Home/Downloads
+  if (NS_FAILED(rv)) {
+    rv = dirService->Get(NS_UNIX_HOME_DIR,
+                         NS_GET_IID(nsIFile),
+                         getter_AddRefs(downloadDir));
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = downloadDir->Append(folderName);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+#endif
+#else
+  rv = dirService->Get(NS_OS_HOME_DIR,
+                       NS_GET_IID(nsIFile),
+                       getter_AddRefs(downloadDir));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = downloadDir->Append(folderName);
+  NS_ENSURE_SUCCESS(rv, rv);
+#endif
+
+  downloadDir.forget(aResult);
+
+  return NS_OK;
+}
+
+#define NS_BRANCH_DOWNLOAD     "browser.download."
+#define NS_PREF_FOLDERLIST     "folderList"
+#define NS_PREF_DIR            "dir"
+
+NS_IMETHODIMP
+nsDownloadManager::GetUserDownloadsDirectory(nsIFile **aResult)
+{
+  nsresult rv;
+  nsCOMPtr<nsIProperties> dirService =
+     do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPrefService> prefService =
+     do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPrefBranch> prefBranch;
+  rv = prefService->GetBranch(NS_BRANCH_DOWNLOAD,
+                              getter_AddRefs(prefBranch));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t val;
+  rv = prefBranch->GetIntPref(NS_PREF_FOLDERLIST,
+                              &val);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  switch(val) {
+    case 0: // Desktop
+      {
+        nsCOMPtr<nsIFile> downloadDir;
+        rv = dirService->Get(NS_OS_DESKTOP_DIR,
+                             NS_GET_IID(nsIFile),
+                             getter_AddRefs(downloadDir));
+        NS_ENSURE_SUCCESS(rv, rv);
+        downloadDir.forget(aResult);
+        return NS_OK;
+      }
+      break;
+    case 1: // Downloads
+      return GetDefaultDownloadsDirectory(aResult);
+    case 2: // Custom
+      {
+        nsCOMPtr<nsIFile> customDirectory;
+        prefBranch->GetComplexValue(NS_PREF_DIR,
+                                    NS_GET_IID(nsIFile),
+                                    getter_AddRefs(customDirectory));
+        if (customDirectory) {
+          bool exists = false;
+          (void)customDirectory->Exists(&exists);
+
+          if (!exists) {
+            rv = customDirectory->Create(nsIFile::DIRECTORY_TYPE, 0755);
+            if (NS_SUCCEEDED(rv)) {
+              customDirectory.forget(aResult);
+              return NS_OK;
+            }
+
+            // Create failed, so it still doesn't exist.  Fall out and get the
+            // default downloads directory.
+          }
+
+          bool writable = false;
+          bool directory = false;
+          (void)customDirectory->IsWritable(&writable);
+          (void)customDirectory->IsDirectory(&directory);
+
+          if (exists && writable && directory) {
+            customDirectory.forget(aResult);
+            return NS_OK;
+          }
+        }
+        rv = GetDefaultDownloadsDirectory(aResult);
+        if (NS_SUCCEEDED(rv)) {
+          (void)prefBranch->SetComplexValue(NS_PREF_DIR,
+                                            NS_GET_IID(nsIFile),
+                                            *aResult);
+        }
+        return rv;
+      }
+      break;
+  }
+  return NS_ERROR_INVALID_ARG;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::AddDownload(DownloadType aDownloadType,
+                               nsIURI *aSource,
+                               nsIURI *aTarget,
+                               const nsAString& aDisplayName,
+                               nsIMIMEInfo *aMIMEInfo,
+                               PRTime aStartTime,
+                               nsIFile *aTempFile,
+                               nsICancelable *aCancelable,
+                               bool aIsPrivate,
+                               nsIDownload **aDownload)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  NS_ENSURE_ARG_POINTER(aSource);
+  NS_ENSURE_ARG_POINTER(aTarget);
+  NS_ENSURE_ARG_POINTER(aDownload);
+
+  nsresult rv;
+
+  // target must be on the local filesystem
+  nsCOMPtr<nsIFileURL> targetFileURL = do_QueryInterface(aTarget, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIFile> targetFile;
+  rv = targetFileURL->GetFile(getter_AddRefs(targetFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  RefPtr<nsDownload> dl = new nsDownload();
+  if (!dl)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  // give our new nsIDownload some info so it's ready to go off into the world
+  dl->mTarget = aTarget;
+  dl->mSource = aSource;
+  dl->mTempFile = aTempFile;
+  dl->mPrivate = aIsPrivate;
+
+  dl->mDisplayName = aDisplayName;
+  if (dl->mDisplayName.IsEmpty())
+    targetFile->GetLeafName(dl->mDisplayName);
+
+  dl->mMIMEInfo = aMIMEInfo;
+  dl->SetStartTime(aStartTime == 0 ? PR_Now() : aStartTime);
+
+  // Creates a cycle that will be broken when the download finishes
+  dl->mCancelable = aCancelable;
+
+  // Adding to the DB
+  nsAutoCString source, target;
+  rv = aSource->GetSpec(source);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = aTarget->GetSpec(target);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Track the temp file for exthandler downloads
+  nsAutoString tempPath;
+  if (aTempFile)
+    aTempFile->GetPath(tempPath);
+
+  // Break down MIMEInfo but don't panic if we can't get all the pieces - we
+  // can still download the file
+  nsAutoCString persistentDescriptor, mimeType;
+  nsHandlerInfoAction action = nsIMIMEInfo::saveToDisk;
+  if (aMIMEInfo) {
+    (void)aMIMEInfo->GetType(mimeType);
+
+    nsCOMPtr<nsIHandlerApp> handlerApp;
+    (void)aMIMEInfo->GetPreferredApplicationHandler(getter_AddRefs(handlerApp));
+    nsCOMPtr<nsILocalHandlerApp> locHandlerApp = do_QueryInterface(handlerApp);
+
+    if (locHandlerApp) {
+      nsCOMPtr<nsIFile> executable;
+      (void)locHandlerApp->GetExecutable(getter_AddRefs(executable));
+      Unused << executable->GetPersistentDescriptor(persistentDescriptor);
+    }
+
+    (void)aMIMEInfo->GetPreferredAction(&action);
+  }
+
+  int64_t id = AddDownloadToDB(dl->mDisplayName, source, target, tempPath,
+                               dl->mStartTime, dl->mLastUpdate,
+                               mimeType, persistentDescriptor, action,
+                               dl->mPrivate, dl->mGUID /* outparam */);
+  NS_ENSURE_TRUE(id, NS_ERROR_FAILURE);
+  dl->mID = id;
+
+  rv = AddToCurrentDownloads(dl);
+  (void)dl->SetState(nsIDownloadManager::DOWNLOAD_QUEUED);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+#ifdef DOWNLOAD_SCANNER
+  if (mScanner) {
+    bool scan = true;
+    nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
+    if (prefs) {
+      (void)prefs->GetBoolPref(PREF_BDM_SCANWHENDONE, &scan);
+    }
+    // We currently apply local security policy to downloads when we scan
+    // via windows all-in-one download security api. The CheckPolicy call
+    // below is a pre-emptive part of that process. So tie applying security
+    // zone policy settings when downloads are intiated to the same pref
+    // that triggers applying security zone policy settings after a download
+    // completes. (bug 504804)
+    if (scan) {
+      AVCheckPolicyState res = mScanner->CheckPolicy(aSource, aTarget);
+      if (res == AVPOLICY_BLOCKED) {
+        // This download will get deleted during a call to IAE's Save,
+        // so go ahead and mark it as blocked and avoid the download.
+        (void)CancelDownload(id);
+        (void)dl->SetState(nsIDownloadManager::DOWNLOAD_BLOCKED_POLICY);
+      }
+    }
+  }
+#endif
+
+  // Check with parental controls to see if file downloads
+  // are allowed for this user. If not allowed, cancel the
+  // download and mark its state as being blocked.
+  nsCOMPtr<nsIParentalControlsService> pc =
+    do_CreateInstance(NS_PARENTALCONTROLSSERVICE_CONTRACTID);
+  if (pc) {
+    bool enabled = false;
+    (void)pc->GetBlockFileDownloadsEnabled(&enabled);
+    if (enabled) {
+      (void)CancelDownload(id);
+      (void)dl->SetState(nsIDownloadManager::DOWNLOAD_BLOCKED_PARENTAL);
+    }
+
+    // Log the event if required by pc settings.
+    bool logEnabled = false;
+    (void)pc->GetLoggingEnabled(&logEnabled);
+    if (logEnabled) {
+      (void)pc->Log(nsIParentalControlsService::ePCLog_FileDownload,
+                    enabled,
+                    aSource,
+                    nullptr);
+    }
+  }
+
+  dl.forget(aDownload);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::GetDownload(uint32_t aID, nsIDownload **aDownloadItem)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  NS_WARNING("Using integer IDs without compat mode enabled");
+
+  nsDownload *itm = FindDownload(aID);
+
+  RefPtr<nsDownload> dl;
+  if (!itm) {
+    nsresult rv = GetDownloadFromDB(aID, getter_AddRefs(dl));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    itm = dl.get();
+  }
+
+  NS_ADDREF(*aDownloadItem = itm);
+
+  return NS_OK;
+}
+
+namespace {
+class AsyncResult : public Runnable
+{
+public:
+  AsyncResult(nsresult aStatus, nsIDownload* aResult,
+              nsIDownloadManagerResult* aCallback)
+  : mStatus(aStatus), mResult(aResult), mCallback(aCallback)
+  {
+  }
+
+  NS_IMETHOD Run() override
+  {
+    mCallback->HandleResult(mStatus, mResult);
+    return NS_OK;
+  }
+
+private:
+  nsresult mStatus;
+  nsCOMPtr<nsIDownload> mResult;
+  nsCOMPtr<nsIDownloadManagerResult> mCallback;
+};
+} // namespace
+
+NS_IMETHODIMP
+nsDownloadManager::GetDownloadByGUID(const nsACString& aGUID,
+                                     nsIDownloadManagerResult* aCallback)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  nsDownload *itm = FindDownload(aGUID);
+
+  nsresult rv = NS_OK;
+  RefPtr<nsDownload> dl;
+  if (!itm) {
+    rv = GetDownloadFromDB(aGUID, getter_AddRefs(dl));
+    itm = dl.get();
+  }
+
+  RefPtr<AsyncResult> runnable = new AsyncResult(rv, itm, aCallback);
+  NS_DispatchToMainThread(runnable);
+  return NS_OK;
+}
+
+nsDownload *
+nsDownloadManager::FindDownload(uint32_t aID)
+{
+  // we shouldn't ever have many downloads, so we can loop over them
+  for (int32_t i = mCurrentDownloads.Count() - 1; i >= 0; --i) {
+    nsDownload *dl = mCurrentDownloads[i];
+    if (dl->mID == aID)
+      return dl;
+  }
+
+  return nullptr;
+}
+
+nsDownload *
+nsDownloadManager::FindDownload(const nsACString& aGUID)
+{
+  // we shouldn't ever have many downloads, so we can loop over them
+  for (int32_t i = mCurrentDownloads.Count() - 1; i >= 0; --i) {
+    nsDownload *dl = mCurrentDownloads[i];
+    if (dl->mGUID == aGUID)
+      return dl;
+  }
+
+  for (int32_t i = mCurrentPrivateDownloads.Count() - 1; i >= 0; --i) {
+    nsDownload *dl = mCurrentPrivateDownloads[i];
+    if (dl->mGUID == aGUID)
+      return dl;
+  }
+
+  return nullptr;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::CancelDownload(uint32_t aID)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  NS_WARNING("Using integer IDs without compat mode enabled");
+
+  // We AddRef here so we don't lose access to member variables when we remove
+  RefPtr<nsDownload> dl = FindDownload(aID);
+
+  // if it's null, someone passed us a bad id.
+  if (!dl)
+    return NS_ERROR_FAILURE;
+
+  return dl->Cancel();
+}
+
+nsresult
+nsDownloadManager::RetryDownload(const nsACString& aGUID)
+{
+  RefPtr<nsDownload> dl;
+  nsresult rv = GetDownloadFromDB(aGUID, getter_AddRefs(dl));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return RetryDownload(dl);
+}
+
+NS_IMETHODIMP
+nsDownloadManager::RetryDownload(uint32_t aID)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  NS_WARNING("Using integer IDs without compat mode enabled");
+
+  RefPtr<nsDownload> dl;
+  nsresult rv = GetDownloadFromDB(aID, getter_AddRefs(dl));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return RetryDownload(dl);
+}
+
+nsresult
+nsDownloadManager::RetryDownload(nsDownload* dl)
+{
+  // if our download is not canceled or failed, we should fail
+  if (dl->mDownloadState != nsIDownloadManager::DOWNLOAD_FAILED &&
+      dl->mDownloadState != nsIDownloadManager::DOWNLOAD_BLOCKED_PARENTAL &&
+      dl->mDownloadState != nsIDownloadManager::DOWNLOAD_BLOCKED_POLICY &&
+      dl->mDownloadState != nsIDownloadManager::DOWNLOAD_DIRTY &&
+      dl->mDownloadState != nsIDownloadManager::DOWNLOAD_CANCELED)
+    return NS_ERROR_FAILURE;
+
+  // If the download has failed and is resumable then we first try resuming it
+  nsresult rv;
+  if (dl->mDownloadState == nsIDownloadManager::DOWNLOAD_FAILED && dl->IsResumable()) {
+    rv = dl->Resume();
+    if (NS_SUCCEEDED(rv))
+      return rv;
+  }
+
+  // reset time and download progress
+  dl->SetStartTime(PR_Now());
+  dl->SetProgressBytes(0, -1);
+
+  nsCOMPtr<nsIWebBrowserPersist> wbp =
+    do_CreateInstance("@mozilla.org/embedding/browser/nsWebBrowserPersist;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = wbp->SetPersistFlags(nsIWebBrowserPersist::PERSIST_FLAGS_REPLACE_EXISTING_FILES |
+                            nsIWebBrowserPersist::PERSIST_FLAGS_AUTODETECT_APPLY_CONVERSION);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = AddToCurrentDownloads(dl);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = dl->SetState(nsIDownloadManager::DOWNLOAD_QUEUED);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Creates a cycle that will be broken when the download finishes
+  dl->mCancelable = wbp;
+  (void)wbp->SetProgressListener(dl);
+
+  // referrer policy can be anything since referrer is nullptr
+  rv = wbp->SavePrivacyAwareURI(dl->mSource, nullptr,
+                                nullptr, mozilla::net::RP_Default,
+                                nullptr, nullptr,
+                                dl->mTarget, dl->mPrivate);
+  if (NS_FAILED(rv)) {
+    dl->mCancelable = nullptr;
+    (void)wbp->SetProgressListener(nullptr);
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+static nsresult
+RemoveDownloadByGUID(const nsACString& aGUID, mozIStorageConnection* aDBConn)
+{
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = aDBConn->CreateStatement(NS_LITERAL_CSTRING(
+    "DELETE FROM moz_downloads "
+    "WHERE guid = :guid"), getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), aGUID);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->Execute();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+nsresult
+nsDownloadManager::RemoveDownload(const nsACString& aGUID)
+{
+  RefPtr<nsDownload> dl = FindDownload(aGUID);
+  MOZ_ASSERT(!dl, "Can't call RemoveDownload on a download in progress!");
+  if (dl)
+    return NS_ERROR_FAILURE;
+
+  nsresult rv = GetDownloadFromDB(aGUID, getter_AddRefs(dl));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (dl->mPrivate) {
+    RemoveDownloadByGUID(aGUID, mPrivateDBConn);
+  } else {
+    RemoveDownloadByGUID(aGUID, mDBConn);
+  }
+
+  return NotifyDownloadRemoval(dl);
+}
+
+NS_IMETHODIMP
+nsDownloadManager::RemoveDownload(uint32_t aID)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  NS_WARNING("Using integer IDs without compat mode enabled");
+
+  RefPtr<nsDownload> dl = FindDownload(aID);
+  MOZ_ASSERT(!dl, "Can't call RemoveDownload on a download in progress!");
+  if (dl)
+    return NS_ERROR_FAILURE;
+
+  nsresult rv = GetDownloadFromDB(aID, getter_AddRefs(dl));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<mozIStorageStatement> stmt;
+  rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(
+    "DELETE FROM moz_downloads "
+    "WHERE id = :id"), getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("id"), aID); // unsigned; 64-bit to prevent overflow
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->Execute();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Notify the UI with the topic and download id
+  return NotifyDownloadRemoval(dl);
+}
+
+nsresult
+nsDownloadManager::NotifyDownloadRemoval(nsDownload* aRemoved)
+{
+  nsCOMPtr<nsISupportsPRUint32> id;
+  nsCOMPtr<nsISupportsCString> guid;
+  nsresult rv;
+
+  // Only send an integer ID notification if the download is public.
+  bool sendDeprecatedNotification = !(aRemoved && aRemoved->mPrivate);
+
+  if (sendDeprecatedNotification && aRemoved) {
+    id = do_CreateInstance(NS_SUPPORTS_PRUINT32_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    uint32_t dlID;
+    rv = aRemoved->GetId(&dlID);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = id->SetData(dlID);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  if (sendDeprecatedNotification) {
+    mObserverService->NotifyObservers(id,
+                                     "download-manager-remove-download",
+                                     nullptr);
+  }
+
+  if (aRemoved) {
+    guid = do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsAutoCString guidStr;
+    rv = aRemoved->GetGuid(guidStr);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = guid->SetData(guidStr);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  mObserverService->NotifyObservers(guid,
+                                    "download-manager-remove-download-guid",
+                                    nullptr);
+  return NS_OK;
+}
+
+static nsresult
+DoRemoveDownloadsByTimeframe(mozIStorageConnection* aDBConn,
+                             int64_t aStartTime,
+                             int64_t aEndTime)
+{
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = aDBConn->CreateStatement(NS_LITERAL_CSTRING(
+    "DELETE FROM moz_downloads "
+    "WHERE startTime >= :startTime "
+    "AND startTime <= :endTime "
+    "AND state NOT IN (:downloading, :paused, :queued)"), getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Bind the times
+  rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("startTime"), aStartTime);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("endTime"), aEndTime);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Bind the active states
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("downloading"), nsIDownloadManager::DOWNLOAD_DOWNLOADING);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("paused"), nsIDownloadManager::DOWNLOAD_PAUSED);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("queued"), nsIDownloadManager::DOWNLOAD_QUEUED);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Execute
+  rv = stmt->Execute();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::RemoveDownloadsByTimeframe(int64_t aStartTime,
+                                              int64_t aEndTime)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  nsresult rv = DoRemoveDownloadsByTimeframe(mDBConn, aStartTime, aEndTime);
+  nsresult rv2 = DoRemoveDownloadsByTimeframe(mPrivateDBConn, aStartTime, aEndTime);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_SUCCESS(rv2, rv2);
+
+  // Notify the UI with the topic and null subject to indicate "remove multiple"
+  return NotifyDownloadRemoval(nullptr);
+}
+
+NS_IMETHODIMP
+nsDownloadManager::CleanUp()
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  return CleanUp(mDBConn);
+}
+
+NS_IMETHODIMP
+nsDownloadManager::CleanUpPrivate()
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  return CleanUp(mPrivateDBConn);
+}
+
+nsresult
+nsDownloadManager::CleanUp(mozIStorageConnection* aDBConn)
+{
+  DownloadState states[] = { nsIDownloadManager::DOWNLOAD_FINISHED,
+                             nsIDownloadManager::DOWNLOAD_FAILED,
+                             nsIDownloadManager::DOWNLOAD_CANCELED,
+                             nsIDownloadManager::DOWNLOAD_BLOCKED_PARENTAL,
+                             nsIDownloadManager::DOWNLOAD_BLOCKED_POLICY,
+                             nsIDownloadManager::DOWNLOAD_DIRTY };
+
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = aDBConn->CreateStatement(NS_LITERAL_CSTRING(
+    "DELETE FROM moz_downloads "
+    "WHERE state = ? "
+      "OR state = ? "
+      "OR state = ? "
+      "OR state = ? "
+      "OR state = ? "
+      "OR state = ?"), getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, rv);
+  for (uint32_t i = 0; i < ArrayLength(states); ++i) {
+    rv = stmt->BindInt32ByIndex(i, states[i]);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  rv = stmt->Execute();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Notify the UI with the topic and null subject to indicate "remove multiple"
+  return NotifyDownloadRemoval(nullptr);
+}
+
+static nsresult
+DoGetCanCleanUp(mozIStorageConnection* aDBConn, bool *aResult)
+{
+  // This method should never return anything but NS_OK for the benefit of
+  // unwitting consumers.
+  
+  *aResult = false;
+
+  DownloadState states[] = { nsIDownloadManager::DOWNLOAD_FINISHED,
+                             nsIDownloadManager::DOWNLOAD_FAILED,
+                             nsIDownloadManager::DOWNLOAD_CANCELED,
+                             nsIDownloadManager::DOWNLOAD_BLOCKED_PARENTAL,
+                             nsIDownloadManager::DOWNLOAD_BLOCKED_POLICY,
+                             nsIDownloadManager::DOWNLOAD_DIRTY };
+
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = aDBConn->CreateStatement(NS_LITERAL_CSTRING(
+    "SELECT COUNT(*) "
+    "FROM moz_downloads "
+    "WHERE state = ? "
+      "OR state = ? "
+      "OR state = ? "
+      "OR state = ? "
+      "OR state = ? "
+      "OR state = ?"), getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, NS_OK);
+  for (uint32_t i = 0; i < ArrayLength(states); ++i) {
+    rv = stmt->BindInt32ByIndex(i, states[i]);
+    NS_ENSURE_SUCCESS(rv, NS_OK);
+  }
+
+  bool moreResults; // We don't really care...
+  rv = stmt->ExecuteStep(&moreResults);
+  NS_ENSURE_SUCCESS(rv, NS_OK);
+
+  int32_t count;
+  rv = stmt->GetInt32(0, &count);
+  NS_ENSURE_SUCCESS(rv, NS_OK);
+
+  if (count > 0)
+    *aResult = true;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::GetCanCleanUp(bool *aResult)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  return DoGetCanCleanUp(mDBConn, aResult);
+}
+
+NS_IMETHODIMP
+nsDownloadManager::GetCanCleanUpPrivate(bool *aResult)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  return DoGetCanCleanUp(mPrivateDBConn, aResult);
+}
+
+NS_IMETHODIMP
+nsDownloadManager::PauseDownload(uint32_t aID)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  NS_WARNING("Using integer IDs without compat mode enabled");
+
+  nsDownload *dl = FindDownload(aID);
+  if (!dl)
+    return NS_ERROR_FAILURE;
+
+  return dl->Pause();
+}
+
+NS_IMETHODIMP
+nsDownloadManager::ResumeDownload(uint32_t aID)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  NS_WARNING("Using integer IDs without compat mode enabled");
+
+  nsDownload *dl = FindDownload(aID);
+  if (!dl)
+    return NS_ERROR_FAILURE;
+
+  return dl->Resume();
+}
+
+NS_IMETHODIMP
+nsDownloadManager::GetDBConnection(mozIStorageConnection **aDBConn)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  NS_ADDREF(*aDBConn = mDBConn);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::GetPrivateDBConnection(mozIStorageConnection **aDBConn)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  NS_ADDREF(*aDBConn = mPrivateDBConn);
+
+  return NS_OK;
+ }
+
+NS_IMETHODIMP
+nsDownloadManager::AddListener(nsIDownloadProgressListener *aListener)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  mListeners.AppendObject(aListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::AddPrivacyAwareListener(nsIDownloadProgressListener *aListener)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  mPrivacyAwareListeners.AppendObject(aListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::RemoveListener(nsIDownloadProgressListener *aListener)
+{
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  mListeners.RemoveObject(aListener);
+  mPrivacyAwareListeners.RemoveObject(aListener);
+  return NS_OK;
+}
+
+void
+nsDownloadManager::NotifyListenersOnDownloadStateChange(int16_t aOldState,
+                                                        nsDownload *aDownload)
+{
+  for (int32_t i = mPrivacyAwareListeners.Count() - 1; i >= 0; --i) {
+    mPrivacyAwareListeners[i]->OnDownloadStateChange(aOldState, aDownload);
+  }
+
+  // Only privacy-aware listeners should receive notifications about private
+  // downloads, while non-privacy-aware listeners receive no sign they exist.
+  if (aDownload->mPrivate) {
+    return;
+  }
+
+  for (int32_t i = mListeners.Count() - 1; i >= 0; --i) {
+    mListeners[i]->OnDownloadStateChange(aOldState, aDownload);
+  }
+}
+
+void
+nsDownloadManager::NotifyListenersOnProgressChange(nsIWebProgress *aProgress,
+                                                   nsIRequest *aRequest,
+                                                   int64_t aCurSelfProgress,
+                                                   int64_t aMaxSelfProgress,
+                                                   int64_t aCurTotalProgress,
+                                                   int64_t aMaxTotalProgress,
+                                                   nsDownload *aDownload)
+{
+  for (int32_t i = mPrivacyAwareListeners.Count() - 1; i >= 0; --i) {
+    mPrivacyAwareListeners[i]->OnProgressChange(aProgress, aRequest, aCurSelfProgress,
+                                                aMaxSelfProgress, aCurTotalProgress,
+                                                aMaxTotalProgress, aDownload);
+  }
+
+  // Only privacy-aware listeners should receive notifications about private
+  // downloads, while non-privacy-aware listeners receive no sign they exist.
+  if (aDownload->mPrivate) {
+    return;
+  }
+
+  for (int32_t i = mListeners.Count() - 1; i >= 0; --i) {
+    mListeners[i]->OnProgressChange(aProgress, aRequest, aCurSelfProgress,
+                                    aMaxSelfProgress, aCurTotalProgress,
+                                    aMaxTotalProgress, aDownload);
+  }
+}
+
+void
+nsDownloadManager::NotifyListenersOnStateChange(nsIWebProgress *aProgress,
+                                                nsIRequest *aRequest,
+                                                uint32_t aStateFlags,
+                                                nsresult aStatus,
+                                                nsDownload *aDownload)
+{
+  for (int32_t i = mPrivacyAwareListeners.Count() - 1; i >= 0; --i) {
+    mPrivacyAwareListeners[i]->OnStateChange(aProgress, aRequest, aStateFlags, aStatus,
+                                             aDownload);
+  }
+
+  // Only privacy-aware listeners should receive notifications about private
+  // downloads, while non-privacy-aware listeners receive no sign they exist.
+  if (aDownload->mPrivate) {
+    return;
+  }
+
+  for (int32_t i = mListeners.Count() - 1; i >= 0; --i) {
+    mListeners[i]->OnStateChange(aProgress, aRequest, aStateFlags, aStatus,
+                                 aDownload);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsINavHistoryObserver
+
+NS_IMETHODIMP
+nsDownloadManager::OnBeginUpdateBatch()
+{
+  // This method in not normally invoked when mUseJSTransfer is enabled, however
+  // we provide an extra check in case it is called manually by add-ons.
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  // We already have a transaction, so don't make another
+  if (mHistoryTransaction)
+    return NS_OK;
+
+  // Start a transaction that commits when deleted
+  mHistoryTransaction = new mozStorageTransaction(mDBConn, true);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::OnEndUpdateBatch()
+{
+  // Get rid of the transaction and cause it to commit
+  mHistoryTransaction = nullptr;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::OnVisit(nsIURI *aURI, int64_t aVisitID, PRTime aTime,
+                           int64_t aSessionID, int64_t aReferringID,
+                           uint32_t aTransitionType, const nsACString& aGUID,
+                           bool aHidden, uint32_t aVisitCount, uint32_t aTyped)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::OnTitleChanged(nsIURI *aURI,
+                                  const nsAString &aPageTitle,
+                                  const nsACString &aGUID)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::OnFrecencyChanged(nsIURI* aURI,
+                                     int32_t aNewFrecency,
+                                     const nsACString& aGUID,
+                                     bool aHidden,
+                                     PRTime aLastVisitDate)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::OnManyFrecenciesChanged()
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::OnDeleteURI(nsIURI *aURI,
+                               const nsACString& aGUID,
+                               uint16_t aReason)
+{
+  // This method in not normally invoked when mUseJSTransfer is enabled, however
+  // we provide an extra check in case it is called manually by add-ons.
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  nsresult rv = RemoveDownloadsForURI(mGetIdsForURIStatement, aURI);
+  nsresult rv2 = RemoveDownloadsForURI(mGetPrivateIdsForURIStatement, aURI);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_SUCCESS(rv2, rv2);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::OnClearHistory()
+{
+  return CleanUp();
+}
+
+NS_IMETHODIMP
+nsDownloadManager::OnPageChanged(nsIURI *aURI,
+                                 uint32_t aChangedAttribute,
+                                 const nsAString& aNewValue,
+                                 const nsACString &aGUID)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownloadManager::OnDeleteVisits(nsIURI *aURI, PRTime aVisitTime,
+                                  const nsACString& aGUID,
+                                  uint16_t aReason, uint32_t aTransitionType)
+{
+  // Don't bother removing downloads until the page is removed.
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsIObserver
+
+NS_IMETHODIMP
+nsDownloadManager::Observe(nsISupports *aSubject,
+                           const char *aTopic,
+                           const char16_t *aData)
+{
+  // This method in not normally invoked when mUseJSTransfer is enabled, however
+  // we provide an extra check in case it is called manually by add-ons.
+  NS_ENSURE_STATE(!mUseJSTransfer);
+
+  // We need to count the active public downloads that could be lost
+  // by quitting, and add any active private ones as well, since per-window
+  // private browsing may be active.
+  int32_t currDownloadCount = mCurrentDownloads.Count();
+
+  // If we don't need to cancel all the downloads on quit, only count the ones
+  // that aren't resumable.
+  if (GetQuitBehavior() != QUIT_AND_CANCEL) {
+    for (int32_t i = currDownloadCount - 1; i >= 0; --i) {
+      if (mCurrentDownloads[i]->IsResumable()) {
+        currDownloadCount--;
+      }
+    }
+
+    // We have a count of the public, non-resumable downloads. Now we need
+    // to add the total number of private downloads, since they are in danger
+    // of being lost.
+    currDownloadCount += mCurrentPrivateDownloads.Count();
+  }
+
+  nsresult rv;
+  if (strcmp(aTopic, "oncancel") == 0) {
+    nsCOMPtr<nsIDownload> dl = do_QueryInterface(aSubject, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    dl->Cancel();
+  } else if (strcmp(aTopic, "profile-before-change") == 0) {
+    CloseAllDBs();
+  } else if (strcmp(aTopic, "quit-application") == 0) {
+    // Try to pause all downloads and, if appropriate, mark them as auto-resume
+    // unless user has specified that downloads should be canceled
+    enum QuitBehavior behavior = GetQuitBehavior();
+    if (behavior != QUIT_AND_CANCEL)
+      (void)PauseAllDownloads(bool(behavior != QUIT_AND_PAUSE));
+
+    // Remove downloads to break cycles and cancel downloads
+    (void)RemoveAllDownloads();
+
+   // Now that active downloads have been canceled, remove all completed or
+   // aborted downloads if the user's retention policy specifies it.
+    if (GetRetentionBehavior() == 1)
+      CleanUp();
+  } else if (strcmp(aTopic, "quit-application-requested") == 0 &&
+             currDownloadCount) {
+    nsCOMPtr<nsISupportsPRBool> cancelDownloads =
+      do_QueryInterface(aSubject, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+#ifndef XP_MACOSX
+    ConfirmCancelDownloads(currDownloadCount, cancelDownloads,
+                           u"quitCancelDownloadsAlertTitle",
+                           u"quitCancelDownloadsAlertMsgMultiple",
+                           u"quitCancelDownloadsAlertMsg",
+                           u"dontQuitButtonWin");
+#else
+    ConfirmCancelDownloads(currDownloadCount, cancelDownloads,
+                           u"quitCancelDownloadsAlertTitle",
+                           u"quitCancelDownloadsAlertMsgMacMultiple",
+                           u"quitCancelDownloadsAlertMsgMac",
+                           u"dontQuitButtonMac");
+#endif
+  } else if (strcmp(aTopic, "offline-requested") == 0 && currDownloadCount) {
+    nsCOMPtr<nsISupportsPRBool> cancelDownloads =
+      do_QueryInterface(aSubject, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    ConfirmCancelDownloads(currDownloadCount, cancelDownloads,
+                           u"offlineCancelDownloadsAlertTitle",
+                           u"offlineCancelDownloadsAlertMsgMultiple",
+                           u"offlineCancelDownloadsAlertMsg",
+                           u"dontGoOfflineButton");
+  }
+  else if (strcmp(aTopic, NS_IOSERVICE_GOING_OFFLINE_TOPIC) == 0) {
+    // Pause all downloads, and mark them to auto-resume.
+    (void)PauseAllDownloads(true);
+  }
+  else if (strcmp(aTopic, NS_IOSERVICE_OFFLINE_STATUS_TOPIC) == 0 &&
+           nsDependentString(aData).EqualsLiteral(NS_IOSERVICE_ONLINE)) {
+    // We can now resume all downloads that are supposed to auto-resume.
+    (void)ResumeAllDownloads(false);
+  }
+  else if (strcmp(aTopic, "alertclickcallback") == 0) {
+    nsCOMPtr<nsIDownloadManagerUI> dmui =
+      do_GetService("@mozilla.org/download-manager-ui;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    return dmui->Show(nullptr, nullptr, nsIDownloadManagerUI::REASON_USER_INTERACTED,
+                      aData && NS_strcmp(aData, u"private") == 0);
+  } else if (strcmp(aTopic, "sleep_notification") == 0 ||
+             strcmp(aTopic, "suspend_process_notification") == 0) {
+    // Pause downloads if we're sleeping, and mark the downloads as auto-resume
+    (void)PauseAllDownloads(true);
+  } else if (strcmp(aTopic, "wake_notification") == 0 ||
+             strcmp(aTopic, "resume_process_notification") == 0) {
+    int32_t resumeOnWakeDelay = 10000;
+    nsCOMPtr<nsIPrefBranch> pref = do_GetService(NS_PREFSERVICE_CONTRACTID);
+    if (pref)
+      (void)pref->GetIntPref(PREF_BDM_RESUMEONWAKEDELAY, &resumeOnWakeDelay);
+
+    // Wait a little bit before trying to resume to avoid resuming when network
+    // connections haven't restarted yet
+    mResumeOnWakeTimer = do_CreateInstance("@mozilla.org/timer;1");
+    if (resumeOnWakeDelay >= 0 && mResumeOnWakeTimer) {
+      (void)mResumeOnWakeTimer->InitWithFuncCallback(ResumeOnWakeCallback,
+        this, resumeOnWakeDelay, nsITimer::TYPE_ONE_SHOT);
+    }
+  } else if (strcmp(aTopic, "last-pb-context-exited") == 0) {
+    // Upon leaving private browsing mode, cancel all private downloads,
+    // remove all trace of them, and then blow away the private database
+    // and recreate a blank one.
+    RemoveAllDownloads(mCurrentPrivateDownloads);
+    InitPrivateDB();
+  } else if (strcmp(aTopic, "last-pb-context-exiting") == 0) {
+    // If there are active private downloads, prompt the user to confirm leaving
+    // private browsing mode (thereby cancelling them). Otherwise, silently proceed.
+    if (!mCurrentPrivateDownloads.Count())
+      return NS_OK;
+
+    nsCOMPtr<nsISupportsPRBool> cancelDownloads = do_QueryInterface(aSubject, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    ConfirmCancelDownloads(mCurrentPrivateDownloads.Count(), cancelDownloads,
+                           u"leavePrivateBrowsingCancelDownloadsAlertTitle",
+                           u"leavePrivateBrowsingWindowsCancelDownloadsAlertMsgMultiple2",
+                           u"leavePrivateBrowsingWindowsCancelDownloadsAlertMsg2",
+                           u"dontLeavePrivateBrowsingButton2");
+  }
+
+  return NS_OK;
+}
+
+void
+nsDownloadManager::ConfirmCancelDownloads(int32_t aCount,
+                                          nsISupportsPRBool *aCancelDownloads,
+                                          const char16_t *aTitle,
+                                          const char16_t *aCancelMessageMultiple,
+                                          const char16_t *aCancelMessageSingle,
+                                          const char16_t *aDontCancelButton)
+{
+  // If user has already dismissed quit request, then do nothing
+  bool quitRequestCancelled = false;
+  aCancelDownloads->GetData(&quitRequestCancelled);
+  if (quitRequestCancelled)
+    return;
+
+  nsXPIDLString title, message, quitButton, dontQuitButton;
+
+  mBundle->GetStringFromName(aTitle, getter_Copies(title));
+
+  nsAutoString countString;
+  countString.AppendInt(aCount);
+  const char16_t *strings[1] = { countString.get() };
+  if (aCount > 1) {
+    mBundle->FormatStringFromName(aCancelMessageMultiple, strings, 1,
+                                  getter_Copies(message));
+    mBundle->FormatStringFromName(u"cancelDownloadsOKTextMultiple",
+                                  strings, 1, getter_Copies(quitButton));
+  } else {
+    mBundle->GetStringFromName(aCancelMessageSingle, getter_Copies(message));
+    mBundle->GetStringFromName(u"cancelDownloadsOKText",
+                               getter_Copies(quitButton));
+  }
+
+  mBundle->GetStringFromName(aDontCancelButton, getter_Copies(dontQuitButton));
+
+  // Get Download Manager window, to be parent of alert.
+  nsCOMPtr<nsIWindowMediator> wm = do_GetService(NS_WINDOWMEDIATOR_CONTRACTID);
+  nsCOMPtr<mozIDOMWindowProxy> dmWindow;
+  if (wm) {
+    wm->GetMostRecentWindow(u"Download:Manager",
+                            getter_AddRefs(dmWindow));
+  }
+
+  // Show alert.
+  nsCOMPtr<nsIPromptService> prompter(do_GetService(NS_PROMPTSERVICE_CONTRACTID));
+  if (prompter) {
+    int32_t flags = (nsIPromptService::BUTTON_TITLE_IS_STRING * nsIPromptService::BUTTON_POS_0) + (nsIPromptService::BUTTON_TITLE_IS_STRING * nsIPromptService::BUTTON_POS_1);
+    bool nothing = false;
+    int32_t button;
+    prompter->ConfirmEx(dmWindow, title, message, flags, quitButton.get(), dontQuitButton.get(), nullptr, nullptr, &nothing, &button);
+
+    aCancelDownloads->SetData(button == 1);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsDownload
+
+NS_IMPL_CLASSINFO(nsDownload, nullptr, 0, NS_DOWNLOAD_CID)
+NS_IMPL_ISUPPORTS_CI(
+    nsDownload
+  , nsIDownload
+  , nsITransfer
+  , nsIWebProgressListener
+  , nsIWebProgressListener2
+)
+
+nsDownload::nsDownload() : mDownloadState(nsIDownloadManager::DOWNLOAD_NOTSTARTED),
+                           mID(0),
+                           mPercentComplete(0),
+                           mCurrBytes(0),
+                           mMaxBytes(-1),
+                           mStartTime(0),
+                           mLastUpdate(PR_Now() - (uint32_t)gUpdateInterval),
+                           mResumedAt(-1),
+                           mSpeed(0),
+                           mHasMultipleFiles(false),
+                           mPrivate(false),
+                           mAutoResume(DONT_RESUME)
+{
+}
+
+nsDownload::~nsDownload()
+{
+}
+
+NS_IMETHODIMP nsDownload::SetSha256Hash(const nsACString& aHash) {
+  MOZ_ASSERT(NS_IsMainThread(), "Must call SetSha256Hash on main thread");
+  // This will be used later to query the application reputation service.
+  mHash = aHash;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsDownload::SetSignatureInfo(nsIArray* aSignatureInfo) {
+  MOZ_ASSERT(NS_IsMainThread(), "Must call SetSignatureInfo on main thread");
+  // This will be used later to query the application reputation service.
+  mSignatureInfo = aSignatureInfo;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsDownload::SetRedirects(nsIArray* aRedirects) {
+  MOZ_ASSERT(NS_IsMainThread(), "Must call SetRedirects on main thread");
+  // This will be used later to query the application reputation service.
+  mRedirects = aRedirects;
+  return NS_OK;
+}
+
+#ifdef MOZ_ENABLE_GIO
+static void gio_set_metadata_done(GObject *source_obj, GAsyncResult *res, gpointer user_data)
+{
+  GError *err = nullptr;
+  g_file_set_attributes_finish(G_FILE(source_obj), res, nullptr, &err);
+  if (err) {
+#ifdef DEBUG
+    NS_DebugBreak(NS_DEBUG_WARNING, "Set file metadata failed: ", err->message, __FILE__, __LINE__);
+#endif
+    g_error_free(err);
+  }
+}
+#endif
+
+nsresult
+nsDownload::SetState(DownloadState aState)
+{
+  NS_ASSERTION(mDownloadState != aState,
+               "Trying to set the download state to what it already is set to!");
+
+  int16_t oldState = mDownloadState;
+  mDownloadState = aState;
+
+  // We don't want to lose access to our member variables
+  RefPtr<nsDownload> kungFuDeathGrip = this;
+
+  // When the state changed listener is dispatched, queries to the database and
+  // the download manager api should reflect what the nsIDownload object would
+  // return. So, if a download is done (finished, canceled, etc.), it should
+  // first be removed from the current downloads.  We will also have to update
+  // the database *before* notifying listeners.  At this point, you can safely
+  // dispatch to the observers as well.
+  switch (aState) {
+    case nsIDownloadManager::DOWNLOAD_BLOCKED_PARENTAL:
+    case nsIDownloadManager::DOWNLOAD_BLOCKED_POLICY:
+    case nsIDownloadManager::DOWNLOAD_DIRTY:
+    case nsIDownloadManager::DOWNLOAD_CANCELED:
+    case nsIDownloadManager::DOWNLOAD_FAILED:
+#ifdef ANDROID
+      // If we still have a temp file, remove it
+      bool tempExists;
+      if (mTempFile && NS_SUCCEEDED(mTempFile->Exists(&tempExists)) && tempExists) {
+        nsresult rv = mTempFile->Remove(false);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+#endif
+
+      // Transfers are finished, so break the reference cycle
+      Finalize();
+      break;
+#ifdef DOWNLOAD_SCANNER
+    case nsIDownloadManager::DOWNLOAD_SCANNING:
+    {
+      nsresult rv = mDownloadManager->mScanner ? mDownloadManager->mScanner->ScanDownload(this) : NS_ERROR_NOT_INITIALIZED;
+      // If we failed, then fall through to 'download finished'
+      if (NS_SUCCEEDED(rv))
+        break;
+      mDownloadState = aState = nsIDownloadManager::DOWNLOAD_FINISHED;
+    }
+#endif
+    case nsIDownloadManager::DOWNLOAD_FINISHED:
+    {
+      nsresult rv = ExecuteDesiredAction();
+      if (NS_FAILED(rv)) {
+        // We've failed to execute the desired action.  As a result, we should
+        // fail the download so the user can try again.
+        (void)FailDownload(rv, nullptr);
+        return rv;
+      }
+
+      // Now that we're done with handling the download, clean it up
+      Finalize();
+
+      nsCOMPtr<nsIPrefBranch> pref(do_GetService(NS_PREFSERVICE_CONTRACTID));
+
+      // Master pref to control this function.
+      bool showTaskbarAlert = true;
+      if (pref)
+        pref->GetBoolPref(PREF_BDM_SHOWALERTONCOMPLETE, &showTaskbarAlert);
+
+      if (showTaskbarAlert) {
+        int32_t alertInterval = 2000;
+        if (pref)
+          pref->GetIntPref(PREF_BDM_SHOWALERTINTERVAL, &alertInterval);
+
+        int64_t alertIntervalUSec = alertInterval * PR_USEC_PER_MSEC;
+        int64_t goat = PR_Now() - mStartTime;
+        showTaskbarAlert = goat > alertIntervalUSec;
+
+        int32_t size = mPrivate ?
+            mDownloadManager->mCurrentPrivateDownloads.Count() :
+            mDownloadManager->mCurrentDownloads.Count();
+        if (showTaskbarAlert && size == 0) {
+          nsCOMPtr<nsIAlertsService> alerts =
+            do_GetService("@mozilla.org/alerts-service;1");
+          if (alerts) {
+              nsXPIDLString title, message;
+
+              mDownloadManager->mBundle->GetStringFromName(
+                  u"downloadsCompleteTitle",
+                  getter_Copies(title));
+              mDownloadManager->mBundle->GetStringFromName(
+                  u"downloadsCompleteMsg",
+                  getter_Copies(message));
+
+              bool removeWhenDone =
+                mDownloadManager->GetRetentionBehavior() == 0;
+
+              // If downloads are automatically removed per the user's
+              // retention policy, there's no reason to make the text clickable
+              // because if it is, they'll click open the download manager and
+              // the items they downloaded will have been removed.
+              alerts->ShowAlertNotification(
+                  NS_LITERAL_STRING(DOWNLOAD_MANAGER_ALERT_ICON), title,
+                  message, !removeWhenDone,
+                  mPrivate ? NS_LITERAL_STRING("private") : NS_LITERAL_STRING("non-private"),
+                  mDownloadManager, EmptyString(), NS_LITERAL_STRING("auto"),
+                  EmptyString(), EmptyString(), nullptr, mPrivate,
+                  false /* requireInteraction */);
+            }
+        }
+      }
+
+#if defined(XP_WIN) || defined(XP_MACOSX) || defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GTK)
+      nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(mTarget);
+      nsCOMPtr<nsIFile> file;
+      nsAutoString path;
+
+      if (fileURL &&
+          NS_SUCCEEDED(fileURL->GetFile(getter_AddRefs(file))) &&
+          file &&
+          NS_SUCCEEDED(file->GetPath(path))) {
+
+#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK) || defined(MOZ_WIDGET_ANDROID)
+        // On Windows and Gtk, add the download to the system's "recent documents"
+        // list, with a pref to disable.
+        {
+          bool addToRecentDocs = true;
+          if (pref)
+            pref->GetBoolPref(PREF_BDM_ADDTORECENTDOCS, &addToRecentDocs);
+#ifdef MOZ_WIDGET_ANDROID
+          if (addToRecentDocs) {
+            nsCOMPtr<nsIMIMEInfo> mimeInfo;
+            nsAutoCString contentType;
+            GetMIMEInfo(getter_AddRefs(mimeInfo));
+
+            if (mimeInfo)
+              mimeInfo->GetMIMEType(contentType);
+
+            if (jni::IsFennec()) {
+                java::DownloadsIntegration::ScanMedia(path, NS_ConvertUTF8toUTF16(contentType));
+            }
+          }
+#else
+          if (addToRecentDocs && !mPrivate) {
+#ifdef XP_WIN
+            ::SHAddToRecentDocs(SHARD_PATHW, path.get());
+#elif defined(MOZ_WIDGET_GTK)
+            GtkRecentManager* manager = gtk_recent_manager_get_default();
+
+            gchar* uri = g_filename_to_uri(NS_ConvertUTF16toUTF8(path).get(),
+                                           nullptr, nullptr);
+            if (uri) {
+              gtk_recent_manager_add_item(manager, uri);
+              g_free(uri);
+            }
+#endif
+          }
+#endif
+#ifdef MOZ_ENABLE_GIO
+          // Use GIO to store the source URI for later display in the file manager.
+          GFile* gio_file = g_file_new_for_path(NS_ConvertUTF16toUTF8(path).get());
+          nsCString source_uri;
+          rv = mSource->GetSpec(source_uri);
+          NS_ENSURE_SUCCESS(rv, rv);
+          GFileInfo *file_info = g_file_info_new();
+          g_file_info_set_attribute_string(file_info, "metadata::download-uri", source_uri.get());
+          g_file_set_attributes_async(gio_file,
+                                      file_info,
+                                      G_FILE_QUERY_INFO_NONE,
+                                      G_PRIORITY_DEFAULT,
+                                      nullptr, gio_set_metadata_done, nullptr);
+          g_object_unref(file_info);
+          g_object_unref(gio_file);
+#endif
+        }
+#endif
+
+#ifdef XP_MACOSX
+        // On OS X, make the downloads stack bounce.
+        CFStringRef observedObject = ::CFStringCreateWithCString(kCFAllocatorDefault,
+                                                 NS_ConvertUTF16toUTF8(path).get(),
+                                                 kCFStringEncodingUTF8);
+        CFNotificationCenterRef center = ::CFNotificationCenterGetDistributedCenter();
+        ::CFNotificationCenterPostNotification(center, CFSTR("com.apple.DownloadFileFinished"),
+                                               observedObject, nullptr, TRUE);
+        ::CFRelease(observedObject);
+#endif
+      }
+
+#ifdef XP_WIN
+      // Adjust file attributes so that by default, new files are indexed
+      // by desktop search services. Skip off those that land in the temp
+      // folder.
+      nsCOMPtr<nsIFile> tempDir, fileDir;
+      rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(tempDir));
+      NS_ENSURE_SUCCESS(rv, rv);
+      (void)file->GetParent(getter_AddRefs(fileDir));
+
+      bool isTemp = false;
+      if (fileDir)
+        (void)fileDir->Equals(tempDir, &isTemp);
+
+      nsCOMPtr<nsILocalFileWin> localFileWin(do_QueryInterface(file));
+      if (!isTemp && localFileWin)
+        (void)localFileWin->SetFileAttributesWin(nsILocalFileWin::WFA_SEARCH_INDEXED);
+#endif
+
+#endif
+      // Now remove the download if the user's retention policy is "Remove when Done"
+      if (mDownloadManager->GetRetentionBehavior() == 0)
+        mDownloadManager->RemoveDownload(mGUID);
+    }
+    break;
+  default:
+    break;
+  }
+
+  // Before notifying the listener, we must update the database so that calls
+  // to it work out properly.
+  nsresult rv = UpdateDB();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mDownloadManager->NotifyListenersOnDownloadStateChange(oldState, this);
+
+  switch (mDownloadState) {
+    case nsIDownloadManager::DOWNLOAD_DOWNLOADING:
+      // Only send the dl-start event to downloads that are actually starting.
+      if (oldState == nsIDownloadManager::DOWNLOAD_QUEUED) {
+        if (!mPrivate)
+          mDownloadManager->SendEvent(this, "dl-start");
+      }
+      break;
+    case nsIDownloadManager::DOWNLOAD_FAILED:
+      if (!mPrivate)
+        mDownloadManager->SendEvent(this, "dl-failed");
+      break;
+    case nsIDownloadManager::DOWNLOAD_SCANNING:
+      if (!mPrivate)
+        mDownloadManager->SendEvent(this, "dl-scanning");
+      break;
+    case nsIDownloadManager::DOWNLOAD_FINISHED:
+      if (!mPrivate)
+        mDownloadManager->SendEvent(this, "dl-done");
+      break;
+    case nsIDownloadManager::DOWNLOAD_BLOCKED_PARENTAL:
+    case nsIDownloadManager::DOWNLOAD_BLOCKED_POLICY:
+      if (!mPrivate)
+        mDownloadManager->SendEvent(this, "dl-blocked");
+      break;
+    case nsIDownloadManager::DOWNLOAD_DIRTY:
+      if (!mPrivate)
+        mDownloadManager->SendEvent(this, "dl-dirty");
+      break;
+    case nsIDownloadManager::DOWNLOAD_CANCELED:
+      if (!mPrivate)
+        mDownloadManager->SendEvent(this, "dl-cancel");
+      break;
+    default:
+      break;
+  }
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsIWebProgressListener2
+
+NS_IMETHODIMP
+nsDownload::OnProgressChange64(nsIWebProgress *aWebProgress,
+                               nsIRequest *aRequest,
+                               int64_t aCurSelfProgress,
+                               int64_t aMaxSelfProgress,
+                               int64_t aCurTotalProgress,
+                               int64_t aMaxTotalProgress)
+{
+  if (!mRequest)
+    mRequest = aRequest; // used for pause/resume
+
+  if (mDownloadState == nsIDownloadManager::DOWNLOAD_QUEUED) {
+    // Obtain the referrer
+    nsresult rv;
+    nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
+    nsCOMPtr<nsIURI> referrer = mReferrer;
+    if (channel)
+      (void)NS_GetReferrerFromChannel(channel, getter_AddRefs(mReferrer));
+
+    // Restore the original referrer if the new one isn't useful
+    if (!mReferrer)
+      mReferrer = referrer;
+
+    // If we have a MIME info, we know that exthandler has already added this to
+    // the history, but if we do not, we'll have to add it ourselves.
+    if (!mMIMEInfo && !mPrivate) {
+      nsCOMPtr<nsIDownloadHistory> dh =
+        do_GetService(NS_DOWNLOADHISTORY_CONTRACTID);
+      if (dh)
+        (void)dh->AddDownload(mSource, mReferrer, mStartTime, mTarget);
+    }
+
+    // Fetch the entityID, but if we can't get it, don't panic (non-resumable)
+    nsCOMPtr<nsIResumableChannel> resumableChannel(do_QueryInterface(aRequest));
+    if (resumableChannel)
+      (void)resumableChannel->GetEntityID(mEntityID);
+
+    // Before we update the state and dispatch state notifications, we want to
+    // ensure that we have the correct state for this download with regards to
+    // its percent completion and size.
+    SetProgressBytes(0, aMaxTotalProgress);
+
+    // Update the state and the database
+    rv = SetState(nsIDownloadManager::DOWNLOAD_DOWNLOADING);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // filter notifications since they come in so frequently
+  PRTime now = PR_Now();
+  PRIntervalTime delta = now - mLastUpdate;
+  if (delta < gUpdateInterval)
+    return NS_OK;
+
+  mLastUpdate = now;
+
+  // Calculate the speed using the elapsed delta time and bytes downloaded
+  // during that time for more accuracy.
+  double elapsedSecs = double(delta) / PR_USEC_PER_SEC;
+  if (elapsedSecs > 0) {
+    double speed = double(aCurTotalProgress - mCurrBytes) / elapsedSecs;
+    if (mCurrBytes == 0) {
+      mSpeed = speed;
+    } else {
+      // Calculate 'smoothed average' of 10 readings.
+      mSpeed = mSpeed * 0.9 + speed * 0.1;
+    }
+  }
+
+  SetProgressBytes(aCurTotalProgress, aMaxTotalProgress);
+
+  // Report to the listener our real sizes
+  int64_t currBytes, maxBytes;
+  (void)GetAmountTransferred(&currBytes);
+  (void)GetSize(&maxBytes);
+  mDownloadManager->NotifyListenersOnProgressChange(
+    aWebProgress, aRequest, currBytes, maxBytes, currBytes, maxBytes, this);
+
+  // If the maximums are different, then there must be more than one file
+  if (aMaxSelfProgress != aMaxTotalProgress)
+    mHasMultipleFiles = true;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::OnRefreshAttempted(nsIWebProgress *aWebProgress,
+                               nsIURI *aUri,
+                               int32_t aDelay,
+                               bool aSameUri,
+                               bool *allowRefresh)
+{
+  *allowRefresh = true;
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsIWebProgressListener
+
+NS_IMETHODIMP
+nsDownload::OnProgressChange(nsIWebProgress *aWebProgress,
+                             nsIRequest *aRequest,
+                             int32_t aCurSelfProgress,
+                             int32_t aMaxSelfProgress,
+                             int32_t aCurTotalProgress,
+                             int32_t aMaxTotalProgress)
+{
+  return OnProgressChange64(aWebProgress, aRequest,
+                            aCurSelfProgress, aMaxSelfProgress,
+                            aCurTotalProgress, aMaxTotalProgress);
+}
+
+NS_IMETHODIMP
+nsDownload::OnLocationChange(nsIWebProgress *aWebProgress,
+                             nsIRequest *aRequest, nsIURI *aLocation,
+                             uint32_t aFlags)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::OnStatusChange(nsIWebProgress *aWebProgress,
+                           nsIRequest *aRequest, nsresult aStatus,
+                           const char16_t *aMessage)
+{
+  if (NS_FAILED(aStatus))
+    return FailDownload(aStatus, aMessage);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::OnStateChange(nsIWebProgress *aWebProgress,
+                          nsIRequest *aRequest, uint32_t aStateFlags,
+                          nsresult aStatus)
+{
+  MOZ_ASSERT(NS_IsMainThread(), "Must call OnStateChange in main thread");
+
+  // We don't want to lose access to our member variables
+  RefPtr<nsDownload> kungFuDeathGrip = this;
+
+  // Check if we're starting a request; the NETWORK flag is necessary to not
+  // pick up the START of *each* file but only for the whole request
+  if ((aStateFlags & STATE_START) && (aStateFlags & STATE_IS_NETWORK)) {
+    nsresult rv;
+    nsCOMPtr<nsIHttpChannel> channel = do_QueryInterface(aRequest, &rv);
+    if (NS_SUCCEEDED(rv)) {
+      uint32_t status;
+      rv = channel->GetResponseStatus(&status);
+      // HTTP 450 - Blocked by parental control proxies
+      if (NS_SUCCEEDED(rv) && status == 450) {
+        // Cancel using the provided object
+        (void)Cancel();
+
+        // Fail the download
+        (void)SetState(nsIDownloadManager::DOWNLOAD_BLOCKED_PARENTAL);
+      }
+    }
+  } else if ((aStateFlags & STATE_STOP) && (aStateFlags & STATE_IS_NETWORK) &&
+             IsFinishable()) {
+    // We got both STOP and NETWORK so that means the whole request is done
+    // (and not just a single file if there are multiple files)
+    if (NS_SUCCEEDED(aStatus)) {
+      // We can't completely trust the bytes we've added up because we might be
+      // missing on some/all of the progress updates (especially from cache).
+      // Our best bet is the file itself, but if for some reason it's gone or
+      // if we have multiple files, the next best is what we've calculated.
+      int64_t fileSize;
+      nsCOMPtr<nsIFile> file;
+      //  We need a nsIFile clone to deal with file size caching issues. :(
+      nsCOMPtr<nsIFile> clone;
+      if (!mHasMultipleFiles &&
+          NS_SUCCEEDED(GetTargetFile(getter_AddRefs(file))) &&
+          NS_SUCCEEDED(file->Clone(getter_AddRefs(clone))) &&
+          NS_SUCCEEDED(clone->GetFileSize(&fileSize)) && fileSize > 0) {
+        mCurrBytes = mMaxBytes = fileSize;
+
+        // If we resumed, keep the fact that we did and fix size calculations
+        if (WasResumed())
+          mResumedAt = 0;
+      } else if (mMaxBytes == -1) {
+        mMaxBytes = mCurrBytes;
+      } else {
+        mCurrBytes = mMaxBytes;
+      }
+
+      mPercentComplete = 100;
+      mLastUpdate = PR_Now();
+
+#ifdef DOWNLOAD_SCANNER
+      bool scan = true;
+      nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
+      if (prefs)
+        (void)prefs->GetBoolPref(PREF_BDM_SCANWHENDONE, &scan);
+
+      if (scan)
+        (void)SetState(nsIDownloadManager::DOWNLOAD_SCANNING);
+      else
+        (void)SetState(nsIDownloadManager::DOWNLOAD_FINISHED);
+#else
+      (void)SetState(nsIDownloadManager::DOWNLOAD_FINISHED);
+#endif
+    } else {
+      // We failed for some unknown reason -- fail with a generic message
+      (void)FailDownload(aStatus, nullptr);
+    }
+  }
+
+  mDownloadManager->NotifyListenersOnStateChange(aWebProgress, aRequest,
+                                                 aStateFlags, aStatus, this);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::OnSecurityChange(nsIWebProgress *aWebProgress,
+                             nsIRequest *aRequest, uint32_t aState)
+{
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsIDownload
+
+NS_IMETHODIMP
+nsDownload::Init(nsIURI *aSource,
+                 nsIURI *aTarget,
+                 const nsAString& aDisplayName,
+                 nsIMIMEInfo *aMIMEInfo,
+                 PRTime aStartTime,
+                 nsIFile *aTempFile,
+                 nsICancelable *aCancelable,
+                 bool aIsPrivate)
+{
+  NS_WARNING("Huh...how did we get here?!");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetState(int16_t *aState)
+{
+  *aState = mDownloadState;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetDisplayName(nsAString &aDisplayName)
+{
+  aDisplayName = mDisplayName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetCancelable(nsICancelable **aCancelable)
+{
+  *aCancelable = mCancelable;
+  NS_IF_ADDREF(*aCancelable);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetTarget(nsIURI **aTarget)
+{
+  *aTarget = mTarget;
+  NS_IF_ADDREF(*aTarget);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetSource(nsIURI **aSource)
+{
+  *aSource = mSource;
+  NS_IF_ADDREF(*aSource);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetStartTime(int64_t *aStartTime)
+{
+  *aStartTime = mStartTime;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetPercentComplete(int32_t *aPercentComplete)
+{
+  *aPercentComplete = mPercentComplete;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetAmountTransferred(int64_t *aAmountTransferred)
+{
+  *aAmountTransferred = mCurrBytes + (WasResumed() ? mResumedAt : 0);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetSize(int64_t *aSize)
+{
+  *aSize = mMaxBytes + (WasResumed() && mMaxBytes != -1 ? mResumedAt : 0);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetMIMEInfo(nsIMIMEInfo **aMIMEInfo)
+{
+  *aMIMEInfo = mMIMEInfo;
+  NS_IF_ADDREF(*aMIMEInfo);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetTargetFile(nsIFile **aTargetFile)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(mTarget, &rv);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  nsCOMPtr<nsIFile> file;
+  rv = fileURL->GetFile(getter_AddRefs(file));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  file.forget(aTargetFile);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsDownload::GetSpeed(double *aSpeed)
+{
+  *aSpeed = mSpeed;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetId(uint32_t *aId)
+{
+  if (mPrivate) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  *aId = mID;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetGuid(nsACString &aGUID)
+{
+  aGUID = mGUID;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetReferrer(nsIURI **referrer)
+{
+  NS_IF_ADDREF(*referrer = mReferrer);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetResumable(bool *resumable)
+{
+  *resumable = IsResumable();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::GetIsPrivate(bool *isPrivate)
+{
+  *isPrivate = mPrivate;
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsDownload Helper Functions
+
+void
+nsDownload::Finalize()
+{
+  // We're stopping, so break the cycle we created at download start
+  mCancelable = nullptr;
+
+  // Reset values that aren't needed anymore, so the DB can be updated as well
+  mEntityID.Truncate();
+  mTempFile = nullptr;
+
+  // Remove ourself from the active downloads
+  nsCOMArray<nsDownload>& currentDownloads = mPrivate ?
+    mDownloadManager->mCurrentPrivateDownloads :
+    mDownloadManager->mCurrentDownloads;
+  (void)currentDownloads.RemoveObject(this);
+
+  // Make sure we do not automatically resume
+  mAutoResume = DONT_RESUME;
+}
+
+nsresult
+nsDownload::ExecuteDesiredAction()
+{
+  // nsExternalHelperAppHandler is the only caller of AddDownload that sets a
+  // tempfile parameter. In this case, execute the desired action according to
+  // the saved mime info.
+  if (!mTempFile) {
+    return NS_OK;
+  }
+
+  // We need to bail if for some reason the temp file got removed
+  bool fileExists;
+  if (NS_FAILED(mTempFile->Exists(&fileExists)) || !fileExists)
+    return NS_ERROR_FILE_NOT_FOUND;
+
+  // Assume an unknown action is save to disk
+  nsHandlerInfoAction action = nsIMIMEInfo::saveToDisk;
+  if (mMIMEInfo) {
+    nsresult rv = mMIMEInfo->GetPreferredAction(&action);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsresult rv = NS_OK;
+  switch (action) {
+    case nsIMIMEInfo::saveToDisk:
+      // Move the file to the proper location
+      rv = MoveTempToTarget();
+      if (NS_SUCCEEDED(rv)) {
+        rv = FixTargetPermissions();
+      }
+      break;
+    case nsIMIMEInfo::useHelperApp:
+    case nsIMIMEInfo::useSystemDefault:
+      // For these cases we have to move the file to the target location and
+      // open with the appropriate application
+      rv = OpenWithApplication();
+      break;
+    default:
+      break;
+  }
+
+  return rv;
+}
+
+nsresult
+nsDownload::FixTargetPermissions()
+{
+  nsCOMPtr<nsIFile> target;
+  nsresult rv = GetTargetFile(getter_AddRefs(target));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Set perms according to umask.
+  nsCOMPtr<nsIPropertyBag2> infoService =
+      do_GetService("@mozilla.org/system-info;1");
+  uint32_t gUserUmask = 0;
+  rv = infoService->GetPropertyAsUint32(NS_LITERAL_STRING("umask"),
+                                        &gUserUmask);
+  if (NS_SUCCEEDED(rv)) {
+    (void)target->SetPermissions(0666 & ~gUserUmask);
+  }
+  return NS_OK;
+}
+
+nsresult
+nsDownload::MoveTempToTarget()
+{
+  nsCOMPtr<nsIFile> target;
+  nsresult rv = GetTargetFile(getter_AddRefs(target));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // MoveTo will fail if the file already exists, but we've already obtained
+  // confirmation from the user that this is OK, so remove it if it exists.
+  bool fileExists;
+  if (NS_SUCCEEDED(target->Exists(&fileExists)) && fileExists) {
+    rv = target->Remove(false);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Extract the new leaf name from the file location
+  nsAutoString fileName;
+  rv = target->GetLeafName(fileName);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIFile> dir;
+  rv = target->GetParent(getter_AddRefs(dir));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = mTempFile->MoveTo(dir, fileName);
+  return rv;
+}
+
+nsresult
+nsDownload::OpenWithApplication()
+{
+  // First move the temporary file to the target location
+  nsCOMPtr<nsIFile> target;
+  nsresult rv = GetTargetFile(getter_AddRefs(target));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Move the temporary file to the target location
+  rv = MoveTempToTarget();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool deleteTempFileOnExit;
+  nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  if (!prefs || NS_FAILED(prefs->GetBoolPref(PREF_BH_DELETETEMPFILEONEXIT,
+                                             &deleteTempFileOnExit))) {
+    // No prefservice or no pref set; use default value
+#if !defined(XP_MACOSX)
+    // Mac users have been very verbal about temp files being deleted on
+    // app exit - they don't like it - but we'll continue to do this on
+    // other platforms for now.
+    deleteTempFileOnExit = true;
+#else
+    deleteTempFileOnExit = false;
+#endif
+  }
+
+  // Always schedule files to be deleted at the end of the private browsing
+  // mode, regardless of the value of the pref.
+  if (deleteTempFileOnExit || mPrivate) {
+
+    // Make the tmp file readonly so users won't lose changes.
+    target->SetPermissions(0400);
+
+    // Use the ExternalHelperAppService to push the temporary file to the list
+    // of files to be deleted on exit.
+    nsCOMPtr<nsPIExternalAppLauncher> appLauncher(do_GetService
+                    (NS_EXTERNALHELPERAPPSERVICE_CONTRACTID));
+
+    // Even if we are unable to get this service we return the result
+    // of LaunchWithFile() which makes more sense.
+    if (appLauncher) {
+      if (mPrivate) {
+        (void)appLauncher->DeleteTemporaryPrivateFileWhenPossible(target);
+      } else {
+        (void)appLauncher->DeleteTemporaryFileOnExit(target);
+      }
+    }
+  }
+
+  return mMIMEInfo->LaunchWithFile(target);
+}
+
+void
+nsDownload::SetStartTime(int64_t aStartTime)
+{
+  mStartTime = aStartTime;
+  mLastUpdate = aStartTime;
+}
+
+void
+nsDownload::SetProgressBytes(int64_t aCurrBytes, int64_t aMaxBytes)
+{
+  mCurrBytes = aCurrBytes;
+  mMaxBytes = aMaxBytes;
+
+  // Get the real bytes that include resume position
+  int64_t currBytes, maxBytes;
+  (void)GetAmountTransferred(&currBytes);
+  (void)GetSize(&maxBytes);
+
+  if (currBytes == maxBytes)
+    mPercentComplete = 100;
+  else if (maxBytes <= 0)
+    mPercentComplete = -1;
+  else
+    mPercentComplete = (int32_t)((double)currBytes / maxBytes * 100 + .5);
+}
+
+NS_IMETHODIMP
+nsDownload::Pause()
+{
+  if (!IsResumable())
+    return NS_ERROR_UNEXPECTED;
+
+  nsresult rv = CancelTransfer();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return SetState(nsIDownloadManager::DOWNLOAD_PAUSED);
+}
+
+nsresult
+nsDownload::CancelTransfer()
+{
+  nsresult rv = NS_OK;
+  if (mCancelable) {
+    rv = mCancelable->Cancel(NS_BINDING_ABORTED);
+    // we're done with this, so break the cycle
+    mCancelable = nullptr;
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsDownload::Cancel()
+{
+  // Don't cancel if download is already finished
+  if (IsFinished())
+    return NS_OK;
+
+  // Have the download cancel its connection
+  (void)CancelTransfer();
+
+  // Dump the temp file because we know we don't need the file anymore. The
+  // underlying transfer creating the file doesn't delete the file because it
+  // can't distinguish between a pause that cancels the transfer or a real
+  // cancel.
+  if (mTempFile) {
+    bool exists;
+    mTempFile->Exists(&exists);
+    if (exists)
+      mTempFile->Remove(false);
+  }
+
+  nsCOMPtr<nsIFile> file;
+  if (NS_SUCCEEDED(GetTargetFile(getter_AddRefs(file))))
+  {
+    bool exists;
+    file->Exists(&exists);
+    if (exists)
+      file->Remove(false);
+  }
+
+  nsresult rv = SetState(nsIDownloadManager::DOWNLOAD_CANCELED);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDownload::Resume()
+{
+  if (!IsPaused() || !IsResumable())
+    return NS_ERROR_UNEXPECTED;
+
+  nsresult rv;
+  nsCOMPtr<nsIWebBrowserPersist> wbp =
+    do_CreateInstance("@mozilla.org/embedding/browser/nsWebBrowserPersist;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = wbp->SetPersistFlags(nsIWebBrowserPersist::PERSIST_FLAGS_APPEND_TO_FILE |
+                            nsIWebBrowserPersist::PERSIST_FLAGS_AUTODETECT_APPLY_CONVERSION);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Create a new channel for the source URI
+  nsCOMPtr<nsIChannel> channel;
+  nsCOMPtr<nsIInterfaceRequestor> ir(do_QueryInterface(wbp));
+  rv = NS_NewChannel(getter_AddRefs(channel),
+                     mSource,
+                     nsContentUtils::GetSystemPrincipal(),
+                     nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
+                     nsIContentPolicy::TYPE_OTHER,
+                     nullptr,  // aLoadGroup
+                     ir);
+
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPrivateBrowsingChannel> pbChannel = do_QueryInterface(channel);
+  if (pbChannel) {
+    pbChannel->SetPrivate(mPrivate);
+  }
+
+  // Make sure we can get a file, either the temporary or the real target, for
+  // both purposes of file size and a target to write to
+  nsCOMPtr<nsIFile> targetLocalFile(mTempFile);
+  if (!targetLocalFile) {
+    rv = GetTargetFile(getter_AddRefs(targetLocalFile));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Get the file size to be used as an offset, but if anything goes wrong
+  // along the way, we'll silently restart at 0.
+  int64_t fileSize;
+  //  We need a nsIFile clone to deal with file size caching issues. :(
+  nsCOMPtr<nsIFile> clone;
+  if (NS_FAILED(targetLocalFile->Clone(getter_AddRefs(clone))) ||
+      NS_FAILED(clone->GetFileSize(&fileSize)))
+    fileSize = 0;
+
+  // Set the channel to resume at the right position along with the entityID
+  nsCOMPtr<nsIResumableChannel> resumableChannel(do_QueryInterface(channel));
+  if (!resumableChannel)
+    return NS_ERROR_UNEXPECTED;
+  rv = resumableChannel->ResumeAt(fileSize, mEntityID);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // If we know the max size, we know what it should be when resuming
+  int64_t maxBytes;
+  GetSize(&maxBytes);
+  SetProgressBytes(0, maxBytes != -1 ? maxBytes - fileSize : -1);
+  // Track where we resumed because progress notifications restart at 0
+  mResumedAt = fileSize;
+
+  // Set the referrer
+  if (mReferrer) {
+    nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
+    if (httpChannel) {
+      rv = httpChannel->SetReferrer(mReferrer);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+
+  // Creates a cycle that will be broken when the download finishes
+  mCancelable = wbp;
+  (void)wbp->SetProgressListener(this);
+
+  // Save the channel using nsIWBP
+  rv = wbp->SaveChannel(channel, targetLocalFile);
+  if (NS_FAILED(rv)) {
+    mCancelable = nullptr;
+    (void)wbp->SetProgressListener(nullptr);
+    return rv;
+  }
+
+  return SetState(nsIDownloadManager::DOWNLOAD_DOWNLOADING);
+}
+
+NS_IMETHODIMP
+nsDownload::Remove()
+{
+  return mDownloadManager->RemoveDownload(mGUID);
+}
+
+NS_IMETHODIMP
+nsDownload::Retry()
+{
+  return mDownloadManager->RetryDownload(mGUID);
+}
+
+bool
+nsDownload::IsPaused()
+{
+  return mDownloadState == nsIDownloadManager::DOWNLOAD_PAUSED;
+}
+
+bool
+nsDownload::IsResumable()
+{
+  return !mEntityID.IsEmpty();
+}
+
+bool
+nsDownload::WasResumed()
+{
+  return mResumedAt != -1;
+}
+
+bool
+nsDownload::ShouldAutoResume()
+{
+  return mAutoResume == AUTO_RESUME;
+}
+
+bool
+nsDownload::IsFinishable()
+{
+  return mDownloadState == nsIDownloadManager::DOWNLOAD_NOTSTARTED ||
+         mDownloadState == nsIDownloadManager::DOWNLOAD_QUEUED ||
+         mDownloadState == nsIDownloadManager::DOWNLOAD_DOWNLOADING;
+}
+
+bool
+nsDownload::IsFinished()
+{
+  return mDownloadState == nsIDownloadManager::DOWNLOAD_FINISHED;
+}
+
+nsresult
+nsDownload::UpdateDB()
+{
+  NS_ASSERTION(mID, "Download ID is stored as zero.  This is bad!");
+  NS_ASSERTION(mDownloadManager, "Egads!  We have no download manager!");
+
+  mozIStorageStatement *stmt = mPrivate ?
+    mDownloadManager->mUpdatePrivateDownloadStatement : mDownloadManager->mUpdateDownloadStatement;
+
+  nsAutoString tempPath;
+  if (mTempFile)
+    (void)mTempFile->GetPath(tempPath);
+  nsresult rv = stmt->BindStringByName(NS_LITERAL_CSTRING("tempPath"), tempPath);
+
+  rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("startTime"), mStartTime);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("endTime"), mLastUpdate);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("state"), mDownloadState);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (mReferrer) {
+    nsAutoCString referrer;
+    rv = mReferrer->GetSpec(referrer);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("referrer"), referrer);
+  } else {
+    rv = stmt->BindNullByName(NS_LITERAL_CSTRING("referrer"));
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("entityID"), mEntityID);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int64_t currBytes;
+  (void)GetAmountTransferred(&currBytes);
+  rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("currBytes"), currBytes);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int64_t maxBytes;
+  (void)GetSize(&maxBytes);
+  rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("maxBytes"), maxBytes);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("autoResume"), mAutoResume);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("id"), mID);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return stmt->Execute();
+}
+
+nsresult
+nsDownload::FailDownload(nsresult aStatus, const char16_t *aMessage)
+{
+  // Grab the bundle before potentially losing our member variables
+  nsCOMPtr<nsIStringBundle> bundle = mDownloadManager->mBundle;
+
+  (void)SetState(nsIDownloadManager::DOWNLOAD_FAILED);
+
+  // Get title for alert.
+  nsXPIDLString title;
+  nsresult rv = bundle->GetStringFromName(
+    u"downloadErrorAlertTitle", getter_Copies(title));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Get a generic message if we weren't supplied one
+  nsXPIDLString message;
+  message = aMessage;
+  if (message.IsEmpty()) {
+    rv = bundle->GetStringFromName(
+      u"downloadErrorGeneric", getter_Copies(message));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Get Download Manager window to be parent of alert
+  nsCOMPtr<nsIWindowMediator> wm =
+    do_GetService(NS_WINDOWMEDIATOR_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<mozIDOMWindowProxy> dmWindow;
+  rv = wm->GetMostRecentWindow(u"Download:Manager",
+                               getter_AddRefs(dmWindow));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Show alert
+  nsCOMPtr<nsIPromptService> prompter =
+    do_GetService("@mozilla.org/embedcomp/prompt-service;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return prompter->Alert(dmWindow, title, message);
+}
diff --git a/toolkit/components/downloads/nsDownloadManager.h b/toolkit/components/downloads/nsDownloadManager.h
new file mode 100644
index 000000000..566e3560a
--- /dev/null
+++ b/toolkit/components/downloads/nsDownloadManager.h
@@ -0,0 +1,454 @@
+/* -*- 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 downloadmanager___h___
+#define downloadmanager___h___
+
+#if defined(XP_WIN)
+#define DOWNLOAD_SCANNER
+#endif
+
+#include "nsIDownload.h"
+#include "nsIDownloadManager.h"
+#include "nsIDownloadProgressListener.h"
+#include "nsIFile.h"
+#include "nsIMIMEInfo.h"
+#include "nsINavHistoryService.h"
+#include "nsIObserver.h"
+#include "nsIObserverService.h"
+#include "nsIStringBundle.h"
+#include "nsISupportsPrimitives.h"
+#include "nsWeakReference.h"
+#include "nsITimer.h"
+#include "nsString.h"
+
+#include "mozIDOMWindow.h"
+#include "mozStorageHelper.h"
+#include "nsAutoPtr.h"
+#include "nsCOMArray.h"
+
+typedef int16_t DownloadState;
+typedef int16_t DownloadType;
+
+class nsIArray;
+class nsDownload;
+
+#ifdef DOWNLOAD_SCANNER
+#include "nsDownloadScanner.h"
+#endif
+
+class nsDownloadManager final : public nsIDownloadManager,
+                                public nsINavHistoryObserver,
+                                public nsIObserver,
+                                public nsSupportsWeakReference
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIDOWNLOADMANAGER
+  NS_DECL_NSINAVHISTORYOBSERVER
+  NS_DECL_NSIOBSERVER
+
+  nsresult Init();
+
+  static nsDownloadManager *GetSingleton();
+
+  nsDownloadManager()
+#ifdef DOWNLOAD_SCANNER
+    : mScanner(nullptr)
+#endif
+  {
+  }
+
+protected:
+  virtual ~nsDownloadManager();
+
+  nsresult InitDB();
+  nsresult InitFileDB();
+  void CloseAllDBs();
+  void CloseDB(mozIStorageConnection* aDBConn,
+               mozIStorageStatement* aUpdateStmt,
+               mozIStorageStatement* aGetIdsStmt);
+  nsresult InitPrivateDB();
+  already_AddRefed<mozIStorageConnection> GetFileDBConnection(nsIFile *dbFile) const;
+  already_AddRefed<mozIStorageConnection> GetPrivateDBConnection() const;
+  nsresult CreateTable(mozIStorageConnection* aDBConn);
+
+  /**
+   * Fix up the database after a crash such as dealing with previously-active
+   * downloads. Call this before RestoreActiveDownloads to get the downloads
+   * fixed here to be auto-resumed.
+   */
+  nsresult RestoreDatabaseState();
+
+  /**
+   * Paused downloads that survive across sessions are considered active, so
+   * rebuild the list of these downloads.
+   */
+  nsresult RestoreActiveDownloads();
+
+  nsresult GetDownloadFromDB(const nsACString& aGUID, nsDownload **retVal);
+  nsresult GetDownloadFromDB(uint32_t aID, nsDownload **retVal);
+  nsresult GetDownloadFromDB(mozIStorageConnection* aDBConn,
+                             mozIStorageStatement* stmt,
+                             nsDownload **retVal);
+
+  /**
+   * Specially track the active downloads so that we don't need to check
+   * every download to see if they're in progress.
+   */
+  nsresult AddToCurrentDownloads(nsDownload *aDl);
+
+  void SendEvent(nsDownload *aDownload, const char *aTopic);
+
+  /**
+   * Adds a download with the specified information to the DB.
+   *
+   * @return The id of the download, or 0 if there was an error.
+   */
+  int64_t AddDownloadToDB(const nsAString &aName,
+                          const nsACString &aSource,
+                          const nsACString &aTarget,
+                          const nsAString &aTempPath,
+                          int64_t aStartTime,
+                          int64_t aEndTime,
+                          const nsACString &aMimeType,
+                          const nsACString &aPreferredApp,
+                          nsHandlerInfoAction aPreferredAction,
+                          bool aPrivate,
+                          nsACString &aNewGUID);
+
+  void NotifyListenersOnDownloadStateChange(int16_t aOldState,
+                                            nsDownload *aDownload);
+  void NotifyListenersOnProgressChange(nsIWebProgress *aProgress,
+                                       nsIRequest *aRequest,
+                                       int64_t aCurSelfProgress,
+                                       int64_t aMaxSelfProgress,
+                                       int64_t aCurTotalProgress,
+                                       int64_t aMaxTotalProgress,
+                                       nsDownload *aDownload);
+  void NotifyListenersOnStateChange(nsIWebProgress *aProgress,
+                                    nsIRequest *aRequest,
+                                    uint32_t aStateFlags,
+                                    nsresult aStatus,
+                                    nsDownload *aDownload);
+
+  nsDownload *FindDownload(const nsACString& aGUID);
+  nsDownload *FindDownload(uint32_t aID);
+
+  /**
+   * First try to resume the download, and if that fails, retry it.
+   *
+   * @param aDl The download to resume and/or retry.
+   */
+  nsresult ResumeRetry(nsDownload *aDl);
+
+  /**
+   * Pause all active downloads and remember if they should try to auto-resume
+   * when the download manager starts again.
+   *
+   * @param aSetResume Indicate if the downloads that get paused should be set
+   *                   as auto-resume.
+   */
+  nsresult PauseAllDownloads(bool aSetResume);
+
+  /**
+   * Resume all paused downloads unless we're only supposed to do the automatic
+   * ones; in that case, try to retry them as well if resuming doesn't work.
+   *
+   * @param aResumeAll If true, all downloads will be resumed; otherwise, only
+   *                   those that are marked as auto-resume will resume.
+   */
+  nsresult ResumeAllDownloads(bool aResumeAll);
+
+  /**
+   * Stop tracking the active downloads. Only use this when we're about to quit
+   * the download manager because we destroy our list of active downloads to
+   * break the dlmgr<->dl cycle. Active downloads that aren't real-paused will
+   * be canceled.
+   */
+  nsresult RemoveAllDownloads();
+
+  /**
+   * Find all downloads from a source URI and delete them.
+   *
+   * @param aURI
+   *        The source URI to remove downloads
+   */
+  nsresult RemoveDownloadsForURI(nsIURI *aURI);
+
+  /**
+   * Callback used for resuming downloads after getting a wake notification.
+   *
+   * @param aTimer
+   *        Timer object fired after some delay after a wake notification
+   * @param aClosure
+   *        nsDownloadManager object used to resume downloads
+   */
+  static void ResumeOnWakeCallback(nsITimer *aTimer, void *aClosure);
+  nsCOMPtr<nsITimer> mResumeOnWakeTimer;
+
+  void ConfirmCancelDownloads(int32_t aCount,
+                              nsISupportsPRBool *aCancelDownloads,
+                              const char16_t *aTitle,
+                              const char16_t *aCancelMessageMultiple,
+                              const char16_t *aCancelMessageSingle,
+                              const char16_t *aDontCancelButton);
+
+  int32_t GetRetentionBehavior();
+
+  /**
+   * Type to indicate possible behaviors for active downloads across sessions.
+   *
+   * Possible values are:
+   *  QUIT_AND_RESUME  - downloads should be auto-resumed
+   *  QUIT_AND_PAUSE   - downloads should be paused
+   *  QUIT_AND_CANCEL  - downloads should be cancelled
+   */
+  enum QuitBehavior {
+    QUIT_AND_RESUME = 0, 
+    QUIT_AND_PAUSE = 1, 
+    QUIT_AND_CANCEL = 2
+  };
+
+  /**
+   * Indicates user-set behavior for active downloads across sessions,
+   *
+   * @return value of user-set pref for active download behavior
+   */
+  enum QuitBehavior GetQuitBehavior();
+
+  void OnEnterPrivateBrowsingMode();
+  void OnLeavePrivateBrowsingMode();
+
+  nsresult RetryDownload(const nsACString& aGUID);
+  nsresult RetryDownload(nsDownload* dl);
+
+  nsresult RemoveDownload(const nsACString& aGUID);
+
+  nsresult NotifyDownloadRemoval(nsDownload* aRemoved);
+
+  // Virus scanner for windows
+#ifdef DOWNLOAD_SCANNER
+private:
+  nsDownloadScanner* mScanner;
+#endif
+
+private:
+  nsresult CleanUp(mozIStorageConnection* aDBConn);
+  nsresult InitStatements(mozIStorageConnection* aDBConn,
+                          mozIStorageStatement** aUpdateStatement,
+                          mozIStorageStatement** aGetIdsStatement);
+  nsresult RemoveAllDownloads(nsCOMArray<nsDownload>& aDownloads);
+  nsresult PauseAllDownloads(nsCOMArray<nsDownload>& aDownloads, bool aSetResume);
+  nsresult ResumeAllDownloads(nsCOMArray<nsDownload>& aDownloads, bool aResumeAll);
+  nsresult RemoveDownloadsForURI(mozIStorageStatement* aStatement, nsIURI *aURI);
+
+  bool mUseJSTransfer;
+  nsCOMArray<nsIDownloadProgressListener> mListeners;
+  nsCOMArray<nsIDownloadProgressListener> mPrivacyAwareListeners;
+  nsCOMPtr<nsIStringBundle> mBundle;
+  nsCOMPtr<mozIStorageConnection> mDBConn;
+  nsCOMPtr<mozIStorageConnection> mPrivateDBConn;
+  nsCOMArray<nsDownload> mCurrentDownloads;
+  nsCOMArray<nsDownload> mCurrentPrivateDownloads;
+  nsCOMPtr<nsIObserverService> mObserverService;
+  nsCOMPtr<mozIStorageStatement> mUpdateDownloadStatement;
+  nsCOMPtr<mozIStorageStatement> mUpdatePrivateDownloadStatement;
+  nsCOMPtr<mozIStorageStatement> mGetIdsForURIStatement;
+  nsCOMPtr<mozIStorageStatement> mGetPrivateIdsForURIStatement;
+  nsAutoPtr<mozStorageTransaction> mHistoryTransaction;
+
+  static nsDownloadManager *gDownloadManagerService;
+
+  friend class nsDownload;
+};
+
+class nsDownload final : public nsIDownload
+{
+public:
+  NS_DECL_NSIWEBPROGRESSLISTENER
+  NS_DECL_NSIWEBPROGRESSLISTENER2
+  NS_DECL_NSITRANSFER
+  NS_DECL_NSIDOWNLOAD
+  NS_DECL_ISUPPORTS
+
+  nsDownload();
+
+  /**
+   * This method MUST be called when changing states on a download.  It will
+   * notify the download listener when a change happens.  This also updates the
+   * database, by calling UpdateDB().
+   */
+  nsresult SetState(DownloadState aState);
+
+protected:
+  virtual ~nsDownload();
+
+  /**
+   * Finish up the download by breaking reference cycles and clearing unneeded
+   * data. Additionally, the download removes itself from the download
+   * manager's list of current downloads.
+   *
+   * NOTE: This method removes the cycle created when starting the download, so
+   * make sure to use kungFuDeathGrip if you want to access member variables.
+   */
+  void Finalize();
+
+  /**
+   * For finished resumed downloads that came in from exthandler, perform the
+   * action that would have been done if the download wasn't resumed.
+   */
+  nsresult ExecuteDesiredAction();
+
+  /**
+   * Move the temporary file to the final destination by removing the existing
+   * dummy target and renaming the temporary.
+   */
+  nsresult MoveTempToTarget();
+
+  /**
+   * Set the target file permissions to be appropriate.
+   */
+  nsresult FixTargetPermissions();
+
+  /**
+   * Update the start time which also implies the last update time is the same.
+   */
+  void SetStartTime(int64_t aStartTime);
+
+  /**
+   * Update the amount of bytes transferred and max bytes; and recalculate the
+   * download percent.
+   */
+  void SetProgressBytes(int64_t aCurrBytes, int64_t aMaxBytes);
+
+  /**
+   * All this does is cancel the connection that the download is using. It does
+   * not remove it from the download manager.
+   */
+  nsresult CancelTransfer();
+
+  /**
+   * Download is not transferring?
+   */
+  bool IsPaused();
+
+  /**
+   * Download can continue from the middle of a transfer?
+   */
+  bool IsResumable();
+
+  /**
+   * Download was resumed?
+   */
+  bool WasResumed();
+
+  /**
+   * Indicates if the download should try to automatically resume or not.
+   */
+  bool ShouldAutoResume();
+
+  /**
+   * Download is in a state to stop and complete the download?
+   */
+  bool IsFinishable();
+
+  /**
+   * Download is totally done transferring and all?
+   */
+  bool IsFinished();
+
+  /**
+   * Update the DB with the current state of the download including time,
+   * download state and other values not known when first creating the
+   * download DB entry.
+   */
+  nsresult UpdateDB();
+
+  /**
+   * Fail a download because of a failure status and prompt the provided
+   * message or use a generic download failure message if nullptr.
+   */
+  nsresult FailDownload(nsresult aStatus, const char16_t *aMessage);
+
+  /**
+   * Opens the downloaded file with the appropriate application, which is
+   * either the OS default, MIME type default, or the one selected by the user.
+   *
+   * This also adds the temporary file to the "To be deleted on Exit" list, if
+   * the corresponding user preference is set (except on OS X).
+   *
+   * This function was adopted from nsExternalAppHandler::OpenWithApplication
+   * (uriloader/exthandler/nsExternalHelperAppService.cpp).
+   */
+  nsresult OpenWithApplication();
+
+  nsDownloadManager *mDownloadManager;
+  nsCOMPtr<nsIURI> mTarget;
+
+private:
+  nsString mDisplayName;
+  nsCString mEntityID;
+  nsCString mGUID;
+
+  nsCOMPtr<nsIURI> mSource;
+  nsCOMPtr<nsIURI> mReferrer;
+  nsCOMPtr<nsICancelable> mCancelable;
+  nsCOMPtr<nsIRequest> mRequest;
+  nsCOMPtr<nsIFile> mTempFile;
+  nsCOMPtr<nsIMIMEInfo> mMIMEInfo;
+
+  DownloadState mDownloadState;
+
+  uint32_t mID;
+  int32_t mPercentComplete;
+
+  /**
+   * These bytes are based on the position of where the request started, so 0
+   * doesn't necessarily mean we have nothing. Use GetAmountTransferred and
+   * GetSize for the real transferred amount and size.
+   */
+  int64_t mCurrBytes;
+  int64_t mMaxBytes;
+
+  PRTime mStartTime;
+  PRTime mLastUpdate;
+  int64_t mResumedAt;
+  double mSpeed;
+
+  bool mHasMultipleFiles;
+  bool mPrivate;
+
+  /**
+   * Track various states of the download trying to auto-resume when starting
+   * the download manager or restoring from a crash.
+   *
+   * DONT_RESUME: Don't automatically resume the download
+   * AUTO_RESUME: Automaically resume the download
+   */
+  enum AutoResume { DONT_RESUME, AUTO_RESUME };
+  AutoResume mAutoResume;
+
+  /**
+   * Stores the SHA-256 hash associated with the downloaded file.
+   */
+  nsCString mHash;
+
+  /**
+   * Stores the certificate chains in an nsIArray of nsIX509CertList of
+   * nsIX509Cert, if this binary is signed.
+   */
+  nsCOMPtr<nsIArray> mSignatureInfo;
+
+  /**
+   * Stores the redirects that led to this download in an nsIArray of
+   * nsIPrincipal.
+   */
+  nsCOMPtr<nsIArray> mRedirects;
+
+  friend class nsDownloadManager;
+};
+
+#endif
diff --git a/toolkit/components/downloads/nsDownloadManagerUI.js b/toolkit/components/downloads/nsDownloadManagerUI.js
new file mode 100644
index 000000000..11e241403
--- /dev/null
+++ b/toolkit/components/downloads/nsDownloadManagerUI.js
@@ -0,0 +1,107 @@
+/* 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/. */
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+
+// Constants
+
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cr = Components.results;
+const DOWNLOAD_MANAGER_URL = "chrome://mozapps/content/downloads/downloads.xul";
+const PREF_FLASH_COUNT = "browser.download.manager.flashCount";
+
+// nsDownloadManagerUI class
+
+function nsDownloadManagerUI() {}
+
+nsDownloadManagerUI.prototype = {
+  classID: Components.ID("7dfdf0d1-aff6-4a34-bad1-d0fe74601642"),
+
+  // nsIDownloadManagerUI
+
+  show: function show(aWindowContext, aDownload, aReason, aUsePrivateUI)
+  {
+    if (!aReason)
+      aReason = Ci.nsIDownloadManagerUI.REASON_USER_INTERACTED;
+
+    // First we see if it is already visible
+    let window = this.recentWindow;
+    if (window) {
+      window.focus();
+
+      // If we are being asked to show again, with a user interaction reason,
+      // set the appropriate variable.
+      if (aReason == Ci.nsIDownloadManagerUI.REASON_USER_INTERACTED)
+        window.gUserInteracted = true;
+      return;
+    }
+
+    let parent = null;
+    // We try to get a window to use as the parent here.  If we don't have one,
+    // the download manager will close immediately after opening if the pref
+    // browser.download.manager.closeWhenDone is set to true.
+    try {
+      if (aWindowContext)
+        parent = aWindowContext.getInterface(Ci.nsIDOMWindow);
+    } catch (e) { /* it's OK to not have a parent window */ }
+
+    // We pass the download manager and the nsIDownload we want selected (if any)
+    var params = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
+    params.appendElement(aDownload, false);
+
+    // Pass in the reason as well
+    let reason = Cc["@mozilla.org/supports-PRInt16;1"].
+                 createInstance(Ci.nsISupportsPRInt16);
+    reason.data = aReason;
+    params.appendElement(reason, false);
+
+    var ww = Cc["@mozilla.org/embedcomp/window-watcher;1"].
+             getService(Ci.nsIWindowWatcher);
+    ww.openWindow(parent,
+                  DOWNLOAD_MANAGER_URL,
+                  "Download:Manager",
+                  "chrome,dialog=no,resizable",
+                  params);
+  },
+
+  get visible() {
+    return (null != this.recentWindow);
+  },
+
+  getAttention: function getAttention()
+  {
+    if (!this.visible)
+      throw Cr.NS_ERROR_UNEXPECTED;
+
+    var prefs = Cc["@mozilla.org/preferences-service;1"].
+                getService(Ci.nsIPrefBranch);
+    // This preference may not be set, so defaulting to two.
+    let flashCount = 2;
+    try {
+      flashCount = prefs.getIntPref(PREF_FLASH_COUNT);
+    } catch (e) { }
+
+    var win = this.recentWindow.QueryInterface(Ci.nsIDOMChromeWindow);
+    win.getAttentionWithCycleCount(flashCount);
+  },
+
+  // nsDownloadManagerUI
+
+  get recentWindow() {
+    var wm = Cc["@mozilla.org/appshell/window-mediator;1"].
+             getService(Ci.nsIWindowMediator);
+    return wm.getMostRecentWindow("Download:Manager");
+  },
+
+  // nsISupports
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIDownloadManagerUI])
+};
+
+// Module
+
+var components = [nsDownloadManagerUI];
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory(components);
+
diff --git a/toolkit/components/downloads/nsDownloadManagerUI.manifest b/toolkit/components/downloads/nsDownloadManagerUI.manifest
new file mode 100644
index 000000000..4073c23fb
--- /dev/null
+++ b/toolkit/components/downloads/nsDownloadManagerUI.manifest
@@ -0,0 +1,2 @@
+component {7dfdf0d1-aff6-4a34-bad1-d0fe74601642} nsDownloadManagerUI.js
+contract @mozilla.org/download-manager-ui;1 {7dfdf0d1-aff6-4a34-bad1-d0fe74601642}
diff --git a/toolkit/components/downloads/nsDownloadProxy.h b/toolkit/components/downloads/nsDownloadProxy.h
new file mode 100644
index 000000000..ca48c9dad
--- /dev/null
+++ b/toolkit/components/downloads/nsDownloadProxy.h
@@ -0,0 +1,179 @@
+/* -*- 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 downloadproxy___h___
+#define downloadproxy___h___
+
+#include "nsIDownloadManager.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "nsIMIMEInfo.h"
+#include "nsIFileURL.h"
+#include "nsIDownloadManagerUI.h"
+
+#define PREF_BDM_SHOWWHENSTARTING "browser.download.manager.showWhenStarting"
+#define PREF_BDM_FOCUSWHENSTARTING "browser.download.manager.focusWhenStarting"
+
+// This class only exists because nsDownload cannot inherit from nsITransfer
+// directly. The reason for this is that nsDownloadManager (incorrectly) keeps
+// an nsCOMArray of nsDownloads, and nsCOMArray is only intended for use with
+// abstract classes. Using a concrete class that multiply inherits from classes
+// deriving from nsISupports will throw ambiguous base class errors.
+class nsDownloadProxy : public nsITransfer
+{
+protected:
+
+  virtual ~nsDownloadProxy() { }
+
+public:
+
+  nsDownloadProxy() { }
+
+  NS_DECL_ISUPPORTS
+
+  NS_IMETHOD Init(nsIURI* aSource,
+                  nsIURI* aTarget,
+                  const nsAString& aDisplayName,
+                  nsIMIMEInfo *aMIMEInfo,
+                  PRTime aStartTime,
+                  nsIFile* aTempFile,
+                  nsICancelable* aCancelable,
+                  bool aIsPrivate) override {
+    nsresult rv;
+    nsCOMPtr<nsIDownloadManager> dm = do_GetService("@mozilla.org/download-manager;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    
+    rv = dm->AddDownload(nsIDownloadManager::DOWNLOAD_TYPE_DOWNLOAD, aSource,
+                         aTarget, aDisplayName, aMIMEInfo, aStartTime,
+                         aTempFile, aCancelable, aIsPrivate,
+                         getter_AddRefs(mInner));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIPrefService> prefs = do_GetService("@mozilla.org/preferences-service;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIPrefBranch> branch = do_QueryInterface(prefs);
+
+    bool showDM = true;
+    if (branch)
+      branch->GetBoolPref(PREF_BDM_SHOWWHENSTARTING, &showDM);
+
+    if (showDM) {
+      nsCOMPtr<nsIDownloadManagerUI> dmui =
+        do_GetService("@mozilla.org/download-manager-ui;1", &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      bool visible;
+      rv = dmui->GetVisible(&visible);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      bool focusWhenStarting = true;
+      if (branch)
+        (void)branch->GetBoolPref(PREF_BDM_FOCUSWHENSTARTING, &focusWhenStarting);
+
+      if (visible && !focusWhenStarting)
+        return NS_OK;
+
+      return dmui->Show(nullptr, mInner, nsIDownloadManagerUI::REASON_NEW_DOWNLOAD, aIsPrivate);
+    }
+    return rv;
+  }
+
+  NS_IMETHOD OnStateChange(nsIWebProgress* aWebProgress,
+                           nsIRequest* aRequest, uint32_t aStateFlags,
+                           nsresult aStatus) override
+  {
+    NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);
+    return mInner->OnStateChange(aWebProgress, aRequest, aStateFlags, aStatus);
+  }
+
+  NS_IMETHOD OnStatusChange(nsIWebProgress *aWebProgress,
+                            nsIRequest *aRequest, nsresult aStatus,
+                            const char16_t *aMessage) override
+  {
+    NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);
+    return mInner->OnStatusChange(aWebProgress, aRequest, aStatus, aMessage);
+  }
+
+  NS_IMETHOD OnLocationChange(nsIWebProgress *aWebProgress,
+                              nsIRequest *aRequest, nsIURI *aLocation,
+                              uint32_t aFlags) override
+  {
+    NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);
+    return mInner->OnLocationChange(aWebProgress, aRequest, aLocation, aFlags);
+  }
+
+  NS_IMETHOD OnProgressChange(nsIWebProgress *aWebProgress,
+                              nsIRequest *aRequest,
+                              int32_t aCurSelfProgress,
+                              int32_t aMaxSelfProgress,
+                              int32_t aCurTotalProgress,
+                              int32_t aMaxTotalProgress) override
+  {
+    NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);
+    return mInner->OnProgressChange(aWebProgress, aRequest,
+                                    aCurSelfProgress,
+                                    aMaxSelfProgress,
+                                    aCurTotalProgress,
+                                    aMaxTotalProgress);
+  }
+
+  NS_IMETHOD OnProgressChange64(nsIWebProgress *aWebProgress,
+                                nsIRequest *aRequest,
+                                int64_t aCurSelfProgress,
+                                int64_t aMaxSelfProgress,
+                                int64_t aCurTotalProgress,
+                                int64_t aMaxTotalProgress) override
+  {
+    NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);
+    return mInner->OnProgressChange64(aWebProgress, aRequest,
+                                      aCurSelfProgress,
+                                      aMaxSelfProgress,
+                                      aCurTotalProgress,
+                                      aMaxTotalProgress);
+  }
+
+  NS_IMETHOD OnRefreshAttempted(nsIWebProgress *aWebProgress,
+                                nsIURI *aUri,
+                                int32_t aDelay,
+                                bool aSameUri,
+                                bool *allowRefresh) override
+  {
+    *allowRefresh = true;
+    return NS_OK;
+  }
+
+  NS_IMETHOD OnSecurityChange(nsIWebProgress *aWebProgress,
+                              nsIRequest *aRequest, uint32_t aState) override
+  {
+    NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);
+    return mInner->OnSecurityChange(aWebProgress, aRequest, aState);
+  }
+
+  NS_IMETHOD SetSha256Hash(const nsACString& aHash) override
+  {
+    NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);
+    return mInner->SetSha256Hash(aHash);
+  }
+
+  NS_IMETHOD SetSignatureInfo(nsIArray* aSignatureInfo) override
+  {
+    NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);
+    return mInner->SetSignatureInfo(aSignatureInfo);
+  }
+
+  NS_IMETHOD SetRedirects(nsIArray* aRedirects) override
+  {
+    NS_ENSURE_TRUE(mInner, NS_ERROR_NOT_INITIALIZED);
+    return mInner->SetRedirects(aRedirects);
+  }
+
+private:
+  nsCOMPtr<nsIDownload> mInner;
+};
+
+NS_IMPL_ISUPPORTS(nsDownloadProxy, nsITransfer,
+                  nsIWebProgressListener, nsIWebProgressListener2)
+
+#endif
diff --git a/toolkit/components/downloads/nsDownloadScanner.cpp b/toolkit/components/downloads/nsDownloadScanner.cpp
new file mode 100644
index 000000000..1ef5b3660
--- /dev/null
+++ b/toolkit/components/downloads/nsDownloadScanner.cpp
@@ -0,0 +1,728 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: se cin sw=2 ts=2 et : */
+/* 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 "nsDownloadScanner.h"
+#include <comcat.h>
+#include <process.h>
+#include "nsDownloadManager.h"
+#include "nsIXULAppInfo.h"
+#include "nsXULAppAPI.h"
+#include "nsIPrefService.h"
+#include "nsNetUtil.h"
+#include "prtime.h"
+#include "nsDeque.h"
+#include "nsIFileURL.h"
+#include "nsIPrefBranch.h"
+#include "nsXPCOMCIDInternal.h"
+
+/**
+ * Code overview
+ *
+ * Download scanner attempts to make use of one of two different virus
+ * scanning interfaces available on Windows - IOfficeAntiVirus (Windows
+ * 95/NT 4 and IE 5) and IAttachmentExecute (XPSP2 and up).  The latter
+ * interface supports calling IOfficeAntiVirus internally, while also
+ * adding support for XPSP2+ ADS forks which define security related
+ * prompting on downloaded content.  
+ *
+ * Both interfaces are synchronous and can take a while, so it is not a
+ * good idea to call either from the main thread. Some antivirus scanners can
+ * take a long time to scan or the call might block while the scanner shows
+ * its UI so if the user were to download many files that finished around the
+ * same time, they would have to wait a while if the scanning were done on
+ * exactly one other thread. Since the overhead of creating a thread is
+ * relatively small compared to the time it takes to download a file and scan
+ * it, a new thread is spawned for each download that is to be scanned. Since
+ * most of the mozilla codebase is not threadsafe, all the information needed
+ * for the scanner is gathered in the main thread in nsDownloadScanner::Scan::Start.
+ * The only function of nsDownloadScanner::Scan which is invoked on another
+ * thread is DoScan.
+ *
+ * Watchdog overview
+ *
+ * The watchdog is used internally by the scanner. It maintains a queue of
+ * current download scans. In a separate thread, it dequeues the oldest scan
+ * and waits on that scan's thread with a timeout given by WATCHDOG_TIMEOUT
+ * (default is 30 seconds). If the wait times out, then the watchdog notifies
+ * the Scan that it has timed out. If the scan really has timed out, then the
+ * Scan object will dispatch its run method to the main thread; this will
+ * release the watchdog thread's addref on the Scan. If it has not timed out
+ * (i.e. the Scan just finished in time), then the watchdog dispatches a 
+ * ReleaseDispatcher to release its ref of the Scan on the main thread.
+ *
+ * In order to minimize execution time, there are two events used to notify the
+ * watchdog thread of a non-empty queue and a quit event. Every blocking wait 
+ * that the watchdog thread does waits on the quit event; this lets the thread
+ * quickly exit when shutting down. Also, the download scan queue will be empty
+ * most of the time; rather than use a spin loop, a simple event is triggered
+ * by the main thread when a new scan is added to an empty queue. When the
+ * watchdog thread knows that it has run out of elements in the queue, it will
+ * wait on the new item event.
+ *
+ * Memory/resource leaks due to timeout:
+ * In the event of a timeout, the thread must remain alive; terminating it may
+ * very well cause the antivirus scanner to crash or be put into an
+ * inconsistent state; COM resources may also not be cleaned up. The downside
+ * is that we need to leave the thread running; suspending it may lead to a
+ * deadlock. Because the scan call may be ongoing, it may be dependent on the
+ * memory referenced by the MSOAVINFO structure, so we cannot free mName, mPath
+ * or mOrigin; this means that we cannot free the Scan object since doing so
+ * will deallocate that memory. Note that mDownload is set to null upon timeout
+ * or completion, so the download itself is never leaked. If the scan does
+ * eventually complete, then the all the memory and resources will be freed.
+ * It is possible, however extremely rare, that in the event of a timeout, the
+ * mStateSync critical section will leak its event; this will happen only if
+ * the scanning thread, watchdog thread or main thread try to enter the
+ * critical section when one of the others is already in it.
+ *
+ * Reasoning for CheckAndSetState - there exists a race condition between the time when
+ * either the timeout or normal scan sets the state and when Scan::Run is
+ * executed on the main thread. Ex: mStatus could be set by Scan::DoScan* which
+ * then queues a dispatch on the main thread. Before that dispatch is executed,
+ * the timeout code fires and sets mStatus to AVSCAN_TIMEDOUT which then queues
+ * its dispatch to the main thread (the same function as DoScan*). Both
+ * dispatches run and both try to set the download state to AVSCAN_TIMEDOUT
+ * which is incorrect.
+ *
+ * There are 5 possible outcomes of the virus scan:
+ *    AVSCAN_GOOD     => the file is clean
+ *    AVSCAN_BAD      => the file has a virus
+ *    AVSCAN_UGLY     => the file had a virus, but it was cleaned
+ *    AVSCAN_FAILED   => something else went wrong with the virus scanner.
+ *    AVSCAN_TIMEDOUT => the scan (thread setup + execution) took too long
+ *
+ * Both the good and ugly states leave the user with a benign file, so they
+ * transition to the finished state. Bad files are sent to the blocked state.
+ * The failed and timedout states transition to finished downloads.
+ *
+ * Possible Future enhancements:
+ *  * Create an interface for scanning files in general
+ *  * Make this a service
+ *  * Get antivirus scanner status via WMI/registry
+ */
+
+// IAttachementExecute supports user definable settings for certain
+// security related prompts. This defines a general GUID for use in
+// all projects. Individual projects can define an individual guid
+// if they want to.
+#ifndef MOZ_VIRUS_SCANNER_PROMPT_GUID
+#define MOZ_VIRUS_SCANNER_PROMPT_GUID \
+  { 0xb50563d1, 0x16b6, 0x43c2, { 0xa6, 0x6a, 0xfa, 0xe6, 0xd2, 0x11, 0xf2, \
+  0xea } }
+#endif
+static const GUID GUID_MozillaVirusScannerPromptGeneric =
+  MOZ_VIRUS_SCANNER_PROMPT_GUID;
+
+// Initial timeout is 30 seconds
+#define WATCHDOG_TIMEOUT (30*PR_USEC_PER_SEC)
+
+// Maximum length for URI's passed into IAE
+#define MAX_IAEURILENGTH 1683
+
+class nsDownloadScannerWatchdog 
+{
+  typedef nsDownloadScanner::Scan Scan;
+public:
+  nsDownloadScannerWatchdog();
+  ~nsDownloadScannerWatchdog();
+
+  nsresult Init();
+  nsresult Shutdown();
+
+  void Watch(Scan *scan);
+private:
+  static unsigned int __stdcall WatchdogThread(void *p);
+  CRITICAL_SECTION mQueueSync;
+  nsDeque mScanQueue;
+  HANDLE mThread;
+  HANDLE mNewItemEvent;
+  HANDLE mQuitEvent;
+};
+
+nsDownloadScanner::nsDownloadScanner() :
+  mAESExists(false)
+{
+}
+ 
+// This destructor appeases the compiler; it would otherwise complain about an
+// incomplete type for nsDownloadWatchdog in the instantiation of
+// nsAutoPtr::~nsAutoPtr
+// Plus, it's a handy location to call nsDownloadScannerWatchdog::Shutdown from
+nsDownloadScanner::~nsDownloadScanner() {
+  if (mWatchdog)
+    (void)mWatchdog->Shutdown();
+}
+
+nsresult
+nsDownloadScanner::Init()
+{
+  // This CoInitialize/CoUninitialize pattern seems to be common in the Mozilla
+  // codebase. All other COM calls/objects are made on different threads.
+  nsresult rv = NS_OK;
+  CoInitialize(nullptr);
+
+  if (!IsAESAvailable()) {
+    CoUninitialize();
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  mAESExists = true;
+
+  // Initialize scanning
+  mWatchdog = new nsDownloadScannerWatchdog();
+  if (mWatchdog) {
+    rv = mWatchdog->Init();
+    if (FAILED(rv))
+      mWatchdog = nullptr;
+  } else {
+    rv = NS_ERROR_OUT_OF_MEMORY;
+  }
+  
+  if (NS_FAILED(rv))
+    return rv;
+
+  return rv;
+}
+
+bool
+nsDownloadScanner::IsAESAvailable()
+{
+  // Try to instantiate IAE to see if it's available.    
+  RefPtr<IAttachmentExecute> ae;
+  HRESULT hr;
+  hr = CoCreateInstance(CLSID_AttachmentServices, nullptr, CLSCTX_INPROC,
+                        IID_IAttachmentExecute, getter_AddRefs(ae));
+  if (FAILED(hr)) {
+    NS_WARNING("Could not instantiate attachment execution service\n");
+    return false;
+  }
+  return true;
+}
+
+// If IAttachementExecute is available, use the CheckPolicy call to find out
+// if this download should be prevented due to Security Zone Policy settings.
+AVCheckPolicyState
+nsDownloadScanner::CheckPolicy(nsIURI *aSource, nsIURI *aTarget)
+{
+  nsresult rv;
+
+  if (!mAESExists || !aSource || !aTarget)
+    return AVPOLICY_DOWNLOAD;
+
+  nsAutoCString source;
+  rv = aSource->GetSpec(source);
+  if (NS_FAILED(rv))
+    return AVPOLICY_DOWNLOAD;
+
+  nsCOMPtr<nsIFileURL> fileUrl(do_QueryInterface(aTarget));
+  if (!fileUrl)
+    return AVPOLICY_DOWNLOAD;
+
+  nsCOMPtr<nsIFile> theFile;
+  nsAutoString aFileName;
+  if (NS_FAILED(fileUrl->GetFile(getter_AddRefs(theFile))) ||
+      NS_FAILED(theFile->GetLeafName(aFileName)))
+    return AVPOLICY_DOWNLOAD;
+
+  // IAttachementExecute prohibits src data: schemes by default but we
+  // support them. If this is a data src, skip off doing a policy check.
+  // (The file will still be scanned once it lands on the local system.)
+  bool isDataScheme(false);
+  nsCOMPtr<nsIURI> innerURI = NS_GetInnermostURI(aSource);
+  if (innerURI)
+    (void)innerURI->SchemeIs("data", &isDataScheme);
+  if (isDataScheme)
+    return AVPOLICY_DOWNLOAD;
+
+  RefPtr<IAttachmentExecute> ae;
+  HRESULT hr;
+  hr = CoCreateInstance(CLSID_AttachmentServices, nullptr, CLSCTX_INPROC,
+                        IID_IAttachmentExecute, getter_AddRefs(ae));
+  if (FAILED(hr))
+    return AVPOLICY_DOWNLOAD;
+
+  (void)ae->SetClientGuid(GUID_MozillaVirusScannerPromptGeneric);
+  (void)ae->SetSource(NS_ConvertUTF8toUTF16(source).get());
+  (void)ae->SetFileName(aFileName.get());
+
+  // Any failure means the file download/exec will be blocked by the system.
+  // S_OK or S_FALSE imply it's ok.
+  hr = ae->CheckPolicy();
+
+  if (hr == S_OK)
+    return AVPOLICY_DOWNLOAD;
+
+  if (hr == S_FALSE)
+    return AVPOLICY_PROMPT;
+
+  if (hr == E_INVALIDARG)
+    return AVPOLICY_PROMPT;
+
+  return AVPOLICY_BLOCKED;
+}
+
+#ifndef THREAD_MODE_BACKGROUND_BEGIN
+#define THREAD_MODE_BACKGROUND_BEGIN 0x00010000
+#endif
+
+#ifndef THREAD_MODE_BACKGROUND_END
+#define THREAD_MODE_BACKGROUND_END 0x00020000
+#endif
+
+unsigned int __stdcall
+nsDownloadScanner::ScannerThreadFunction(void *p)
+{
+  HANDLE currentThread = GetCurrentThread();
+  NS_ASSERTION(!NS_IsMainThread(), "Antivirus scan should not be run on the main thread");
+  nsDownloadScanner::Scan *scan = static_cast<nsDownloadScanner::Scan*>(p);
+  if (!SetThreadPriority(currentThread, THREAD_MODE_BACKGROUND_BEGIN))
+    (void)SetThreadPriority(currentThread, THREAD_PRIORITY_IDLE);
+  scan->DoScan();
+  (void)SetThreadPriority(currentThread, THREAD_MODE_BACKGROUND_END);
+  _endthreadex(0);
+  return 0;
+}
+
+// The sole purpose of this class is to release an object on the main thread
+// It assumes that its creator will addref it and it will release itself on
+// the main thread too
+class ReleaseDispatcher : public mozilla::Runnable {
+public:
+  ReleaseDispatcher(nsISupports *ptr)
+    : mPtr(ptr) {}
+  NS_IMETHOD Run();
+private:
+  nsISupports *mPtr;
+};
+
+nsresult ReleaseDispatcher::Run() {
+  NS_ASSERTION(NS_IsMainThread(), "Antivirus scan release dispatch should be run on the main thread");
+  NS_RELEASE(mPtr);
+  NS_RELEASE_THIS();
+  return NS_OK;
+}
+
+nsDownloadScanner::Scan::Scan(nsDownloadScanner *scanner, nsDownload *download)
+  : mDLScanner(scanner), mThread(nullptr), 
+    mDownload(download), mStatus(AVSCAN_NOTSTARTED),
+    mSkipSource(false)
+{
+  InitializeCriticalSection(&mStateSync);
+}
+
+nsDownloadScanner::Scan::~Scan() {
+  DeleteCriticalSection(&mStateSync);
+}
+
+nsresult
+nsDownloadScanner::Scan::Start()
+{
+  mStartTime = PR_Now();
+
+  mThread = (HANDLE)_beginthreadex(nullptr, 0, ScannerThreadFunction,
+      this, CREATE_SUSPENDED, nullptr);
+  if (!mThread)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  nsresult rv = NS_OK;
+
+  // Get the path to the file on disk
+  nsCOMPtr<nsIFile> file;
+  rv = mDownload->GetTargetFile(getter_AddRefs(file));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = file->GetPath(mPath);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Grab the app name
+  nsCOMPtr<nsIXULAppInfo> appinfo =
+    do_GetService(XULAPPINFO_SERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString name;
+  rv = appinfo->GetName(name);
+  NS_ENSURE_SUCCESS(rv, rv);
+  CopyUTF8toUTF16(name, mName);
+
+  // Get the origin
+  nsCOMPtr<nsIURI> uri;
+  rv = mDownload->GetSource(getter_AddRefs(uri));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString origin;
+  rv = uri->GetSpec(origin);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Certain virus interfaces do not like extremely long uris.
+  // Chop off the path and cgi data and just pass the base domain. 
+  if (origin.Length() > MAX_IAEURILENGTH) {
+    rv = uri->GetPrePath(origin);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  CopyUTF8toUTF16(origin, mOrigin);
+
+  // We count https/ftp/http as an http download
+  bool isHttp(false), isFtp(false), isHttps(false);
+  nsCOMPtr<nsIURI> innerURI = NS_GetInnermostURI(uri);
+  if (!innerURI) innerURI = uri;
+  (void)innerURI->SchemeIs("http", &isHttp);
+  (void)innerURI->SchemeIs("ftp", &isFtp);
+  (void)innerURI->SchemeIs("https", &isHttps);
+  mIsHttpDownload = isHttp || isFtp || isHttps;
+
+  // IAttachementExecute prohibits src data: schemes by default but we
+  // support them. Mark the download if it's a data scheme, so we
+  // can skip off supplying the src to IAttachementExecute when we scan
+  // the resulting file.
+  (void)innerURI->SchemeIs("data", &mSkipSource);
+
+  // ResumeThread returns the previous suspend count
+  if (1 != ::ResumeThread(mThread)) {
+    CloseHandle(mThread);
+    return NS_ERROR_UNEXPECTED;
+  }
+  return NS_OK;
+}
+
+nsresult
+nsDownloadScanner::Scan::Run()
+{
+  NS_ASSERTION(NS_IsMainThread(), "Antivirus scan dispatch should be run on the main thread");
+
+  // Cleanup our thread
+  if (mStatus != AVSCAN_TIMEDOUT)
+    WaitForSingleObject(mThread, INFINITE);
+  CloseHandle(mThread);
+
+  DownloadState downloadState = 0;
+  EnterCriticalSection(&mStateSync);
+  switch (mStatus) {
+    case AVSCAN_BAD:
+      downloadState = nsIDownloadManager::DOWNLOAD_DIRTY;
+      break;
+    default:
+    case AVSCAN_FAILED:
+    case AVSCAN_GOOD:
+    case AVSCAN_UGLY:
+    case AVSCAN_TIMEDOUT:
+      downloadState = nsIDownloadManager::DOWNLOAD_FINISHED;
+      break;
+  }
+  LeaveCriticalSection(&mStateSync);
+  // Download will be null if we already timed out
+  if (mDownload)
+    (void)mDownload->SetState(downloadState);
+
+  // Clean up some other variables
+  // In the event of a timeout, our destructor won't be called
+  mDownload = nullptr;
+
+  NS_RELEASE_THIS();
+  return NS_OK;
+}
+
+static DWORD
+ExceptionFilterFunction(DWORD exceptionCode) {
+  switch(exceptionCode) {
+    case EXCEPTION_ACCESS_VIOLATION:
+    case EXCEPTION_ILLEGAL_INSTRUCTION:
+    case EXCEPTION_IN_PAGE_ERROR:
+    case EXCEPTION_PRIV_INSTRUCTION:
+    case EXCEPTION_STACK_OVERFLOW:
+      return EXCEPTION_EXECUTE_HANDLER;
+    default:
+      return EXCEPTION_CONTINUE_SEARCH;
+  }
+}
+
+bool
+nsDownloadScanner::Scan::DoScanAES()
+{
+  // This warning is for the destructor of ae which will not be invoked in the
+  // event of a win32 exception
+#pragma warning(disable: 4509)
+  HRESULT hr;
+  RefPtr<IAttachmentExecute> ae;
+  MOZ_SEH_TRY {
+    hr = CoCreateInstance(CLSID_AttachmentServices, nullptr, CLSCTX_ALL,
+                          IID_IAttachmentExecute, getter_AddRefs(ae));
+  } MOZ_SEH_EXCEPT(ExceptionFilterFunction(GetExceptionCode())) {
+    return CheckAndSetState(AVSCAN_NOTSTARTED,AVSCAN_FAILED);
+  }
+
+  // If we (somehow) already timed out, then don't bother scanning
+  if (CheckAndSetState(AVSCAN_SCANNING, AVSCAN_NOTSTARTED)) {
+    AVScanState newState;
+    if (SUCCEEDED(hr)) {
+      bool gotException = false;
+      MOZ_SEH_TRY {
+        (void)ae->SetClientGuid(GUID_MozillaVirusScannerPromptGeneric);
+        (void)ae->SetLocalPath(mPath.get());
+        // Provide the src for everything but data: schemes.
+        if (!mSkipSource)
+          (void)ae->SetSource(mOrigin.get());
+
+        // Save() will invoke the scanner
+        hr = ae->Save();
+      } MOZ_SEH_EXCEPT(ExceptionFilterFunction(GetExceptionCode())) {
+        gotException = true;
+      }
+
+      MOZ_SEH_TRY {
+        ae = nullptr;
+      } MOZ_SEH_EXCEPT(ExceptionFilterFunction(GetExceptionCode())) {
+        gotException = true;
+      }
+
+      if(gotException) {
+        newState = AVSCAN_FAILED;
+      }
+      else if (SUCCEEDED(hr)) { // Passed the scan
+        newState = AVSCAN_GOOD;
+      }
+      else if (HRESULT_CODE(hr) == ERROR_FILE_NOT_FOUND) {
+        NS_WARNING("Downloaded file disappeared before it could be scanned");
+        newState = AVSCAN_FAILED;
+      }
+      else if (hr == E_INVALIDARG) {
+        NS_WARNING("IAttachementExecute returned invalid argument error");
+        newState = AVSCAN_FAILED;
+      }
+      else { 
+        newState = AVSCAN_UGLY;
+      }
+    }
+    else {
+      newState = AVSCAN_FAILED;
+    }
+    return CheckAndSetState(newState, AVSCAN_SCANNING);
+  }
+  return false;
+}
+#pragma warning(default: 4509)
+
+void
+nsDownloadScanner::Scan::DoScan()
+{
+  CoInitialize(nullptr);
+
+  if (DoScanAES()) {
+    // We need to do a few more things on the main thread
+    NS_DispatchToMainThread(this);
+  } else {
+    // We timed out, so just release
+    ReleaseDispatcher* releaser = new ReleaseDispatcher(this);
+    if(releaser) {
+      NS_ADDREF(releaser);
+      NS_DispatchToMainThread(releaser);
+    }
+  }
+
+  MOZ_SEH_TRY {
+    CoUninitialize();
+  } MOZ_SEH_EXCEPT(ExceptionFilterFunction(GetExceptionCode())) {
+    // Not much we can do at this point...
+  }
+}
+
+HANDLE
+nsDownloadScanner::Scan::GetWaitableThreadHandle() const
+{
+  HANDLE targetHandle = INVALID_HANDLE_VALUE;
+  (void)DuplicateHandle(GetCurrentProcess(), mThread,
+                        GetCurrentProcess(), &targetHandle,
+                        SYNCHRONIZE, // Only allow clients to wait on this handle
+                        FALSE, // cannot be inherited by child processes
+                        0);
+  return targetHandle;
+}
+
+bool
+nsDownloadScanner::Scan::NotifyTimeout()
+{
+  bool didTimeout = CheckAndSetState(AVSCAN_TIMEDOUT, AVSCAN_SCANNING) ||
+                      CheckAndSetState(AVSCAN_TIMEDOUT, AVSCAN_NOTSTARTED);
+  if (didTimeout) {
+    // We need to do a few more things on the main thread
+    NS_DispatchToMainThread(this);
+  }
+  return didTimeout;
+}
+
+bool
+nsDownloadScanner::Scan::CheckAndSetState(AVScanState newState, AVScanState expectedState) {
+  bool gotExpectedState = false;
+  EnterCriticalSection(&mStateSync);
+  if((gotExpectedState = (mStatus == expectedState)))
+    mStatus = newState;
+  LeaveCriticalSection(&mStateSync);
+  return gotExpectedState;
+}
+
+nsresult
+nsDownloadScanner::ScanDownload(nsDownload *download)
+{
+  if (!mAESExists)
+    return NS_ERROR_NOT_AVAILABLE;
+
+  // No ref ptr, see comment below
+  Scan *scan = new Scan(this, download);
+  if (!scan)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  NS_ADDREF(scan);
+
+  nsresult rv = scan->Start();
+
+  // Note that we only release upon error. On success, the scan is passed off
+  // to a new thread. It is eventually released in Scan::Run on the main thread.
+  if (NS_FAILED(rv))
+    NS_RELEASE(scan);
+  else
+    // Notify the watchdog
+    mWatchdog->Watch(scan);
+
+  return rv;
+}
+
+nsDownloadScannerWatchdog::nsDownloadScannerWatchdog() 
+  : mNewItemEvent(nullptr), mQuitEvent(nullptr) {
+  InitializeCriticalSection(&mQueueSync);
+}
+nsDownloadScannerWatchdog::~nsDownloadScannerWatchdog() {
+  DeleteCriticalSection(&mQueueSync);
+}
+
+nsresult
+nsDownloadScannerWatchdog::Init() {
+  // Both events are auto-reset
+  mNewItemEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
+  if (INVALID_HANDLE_VALUE == mNewItemEvent)
+    return NS_ERROR_OUT_OF_MEMORY;
+  mQuitEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
+  if (INVALID_HANDLE_VALUE == mQuitEvent) {
+    (void)CloseHandle(mNewItemEvent);
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  // This thread is always running, however it will be asleep
+  // for most of the dlmgr's lifetime
+  mThread = (HANDLE)_beginthreadex(nullptr, 0, WatchdogThread,
+                                   this, 0, nullptr);
+  if (!mThread) {
+    (void)CloseHandle(mNewItemEvent);
+    (void)CloseHandle(mQuitEvent);
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsDownloadScannerWatchdog::Shutdown() {
+  // Tell the watchdog thread to quite
+  (void)SetEvent(mQuitEvent);
+  (void)WaitForSingleObject(mThread, INFINITE);
+  (void)CloseHandle(mThread);
+  // Manually clear and release the queued scans
+  while (mScanQueue.GetSize() != 0) {
+    Scan *scan = reinterpret_cast<Scan*>(mScanQueue.Pop());
+    NS_RELEASE(scan);
+  }
+  (void)CloseHandle(mNewItemEvent);
+  (void)CloseHandle(mQuitEvent);
+  return NS_OK;
+}
+
+void
+nsDownloadScannerWatchdog::Watch(Scan *scan) {
+  bool wasEmpty;
+  // Note that there is no release in this method
+  // The scan will be released by the watchdog ALWAYS on the main thread
+  // when either the watchdog thread processes the scan or the watchdog
+  // is shut down
+  NS_ADDREF(scan);
+  EnterCriticalSection(&mQueueSync);
+  wasEmpty = mScanQueue.GetSize()==0;
+  mScanQueue.Push(scan);
+  LeaveCriticalSection(&mQueueSync);
+  // If the queue was empty, then the watchdog thread is/will be asleep
+  if (wasEmpty)
+    (void)SetEvent(mNewItemEvent);
+}
+
+unsigned int
+__stdcall
+nsDownloadScannerWatchdog::WatchdogThread(void *p) {
+  NS_ASSERTION(!NS_IsMainThread(), "Antivirus scan watchdog should not be run on the main thread");
+  nsDownloadScannerWatchdog *watchdog = (nsDownloadScannerWatchdog*)p;
+  HANDLE waitHandles[3] = {watchdog->mNewItemEvent, watchdog->mQuitEvent, INVALID_HANDLE_VALUE};
+  DWORD waitStatus;
+  DWORD queueItemsLeft = 0;
+  // Loop until quit event or error
+  while (0 != queueItemsLeft ||
+         ((WAIT_OBJECT_0 + 1) !=
+           (waitStatus =
+              WaitForMultipleObjects(2, waitHandles, FALSE, INFINITE)) &&
+         waitStatus != WAIT_FAILED)) {
+    Scan *scan = nullptr;
+    PRTime startTime, expectedEndTime, now;
+    DWORD waitTime;
+
+    // Pop scan from queue
+    EnterCriticalSection(&watchdog->mQueueSync);
+    scan = reinterpret_cast<Scan*>(watchdog->mScanQueue.Pop());
+    queueItemsLeft = watchdog->mScanQueue.GetSize();
+    LeaveCriticalSection(&watchdog->mQueueSync);
+
+    // Calculate expected end time
+    startTime = scan->GetStartTime();
+    expectedEndTime = WATCHDOG_TIMEOUT + startTime;
+    now = PR_Now();
+    // PRTime is not guaranteed to be a signed integral type (afaik), but
+    // currently it is
+    if (now > expectedEndTime) {
+      waitTime = 0;
+    } else {
+      // This is a positive value, and we know that it will not overflow
+      // (bounded by WATCHDOG_TIMEOUT)
+      // waitTime is in milliseconds, nspr uses microseconds
+      waitTime = static_cast<DWORD>((expectedEndTime - now)/PR_USEC_PER_MSEC);
+    }
+    HANDLE hThread = waitHandles[2] = scan->GetWaitableThreadHandle();
+
+    // Wait for the thread (obj 1) or quit event (obj 0)
+    waitStatus = WaitForMultipleObjects(2, (waitHandles+1), FALSE, waitTime);
+    CloseHandle(hThread);
+
+    ReleaseDispatcher* releaser = new ReleaseDispatcher(scan);
+    if(!releaser)
+      continue;
+    NS_ADDREF(releaser);
+    // Got quit event or error
+    if (waitStatus == WAIT_FAILED || waitStatus == WAIT_OBJECT_0) {
+      NS_DispatchToMainThread(releaser);
+      break;
+    // Thread exited normally
+    } else if (waitStatus == (WAIT_OBJECT_0+1)) {
+      NS_DispatchToMainThread(releaser);
+      continue;
+    // Timeout case
+    } else { 
+      NS_ASSERTION(waitStatus == WAIT_TIMEOUT, "Unexpected wait status in dlmgr watchdog thread");
+      if (!scan->NotifyTimeout()) {
+        // If we didn't time out, then release the thread
+        NS_DispatchToMainThread(releaser);
+      } else {
+        // NotifyTimeout did a dispatch which will release the scan, so we
+        // don't need to release the scan
+        NS_RELEASE(releaser);
+      }
+    }
+  }
+  _endthreadex(0);
+  return 0;
+}
diff --git a/toolkit/components/downloads/nsDownloadScanner.h b/toolkit/components/downloads/nsDownloadScanner.h
new file mode 100644
index 000000000..3301489fe
--- /dev/null
+++ b/toolkit/components/downloads/nsDownloadScanner.h
@@ -0,0 +1,121 @@
+/* -*- 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/. */
+
+/* vim: se cin sw=2 ts=2 et : */
+
+#ifndef nsDownloadScanner_h_
+#define nsDownloadScanner_h_
+
+#ifdef WIN32_LEAN_AND_MEAN
+#undef WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#define AVVENDOR
+#include <objidl.h>
+#include <msoav.h>
+#include <shlobj.h>
+
+#include "nsAutoPtr.h"
+#include "nsThreadUtils.h"
+#include "nsTArray.h"
+#include "nsIObserver.h"
+#include "nsIURI.h"
+
+enum AVScanState
+{
+  AVSCAN_NOTSTARTED = 0,
+  AVSCAN_SCANNING,
+  AVSCAN_GOOD,
+  AVSCAN_BAD,
+  AVSCAN_UGLY,
+  AVSCAN_FAILED,
+  AVSCAN_TIMEDOUT
+};
+
+enum AVCheckPolicyState
+{
+  AVPOLICY_DOWNLOAD,
+  AVPOLICY_PROMPT,
+  AVPOLICY_BLOCKED
+};
+
+// See nsDownloadScanner.cpp for declaration and definition
+class nsDownloadScannerWatchdog;
+class nsDownload;
+
+class nsDownloadScanner
+{
+public:
+  nsDownloadScanner();
+  ~nsDownloadScanner();
+  nsresult Init();
+  nsresult ScanDownload(nsDownload *download);
+  AVCheckPolicyState CheckPolicy(nsIURI *aSource, nsIURI *aTarget);
+
+private:
+  bool mAESExists;
+  nsTArray<CLSID> mScanCLSID;
+  bool IsAESAvailable();
+  bool EnumerateOAVProviders();
+
+  nsAutoPtr<nsDownloadScannerWatchdog> mWatchdog;
+
+  static unsigned int __stdcall ScannerThreadFunction(void *p);
+  class Scan : public mozilla::Runnable
+  {
+  public:
+    Scan(nsDownloadScanner *scanner, nsDownload *download);
+    ~Scan();
+    nsresult Start();
+
+    // Returns the time that Start was called
+    PRTime GetStartTime() const { return mStartTime; }
+    // Returns a copy of the thread handle that can be waited on, but not
+    // terminated
+    // The caller is responsible for closing the handle
+    // If the thread has terminated, then this will return the pseudo-handle
+    // INVALID_HANDLE_VALUE
+    HANDLE GetWaitableThreadHandle() const;
+
+    // Called on a secondary thread to notify the scan that it has timed out
+    // this is used only by the watchdog thread
+    bool NotifyTimeout();
+
+  private:
+    nsDownloadScanner *mDLScanner;
+    PRTime mStartTime;
+    HANDLE mThread;
+    RefPtr<nsDownload> mDownload;
+    // Guards mStatus
+    CRITICAL_SECTION mStateSync;
+    AVScanState mStatus;
+    nsString mPath;
+    nsString mName;
+    nsString mOrigin;
+    // Also true if it is an ftp download
+    bool mIsHttpDownload;
+    bool mSkipSource;
+
+    /* @summary Sets the Scan's state to newState if the current state is
+                expectedState
+     * @param newState The new state of the scan
+     * @param expectedState The state that the caller expects the scan to be in
+     * @return If the old state matched expectedState
+     */
+    bool CheckAndSetState(AVScanState newState, AVScanState expectedState);
+
+    NS_IMETHOD Run();
+
+    void DoScan();
+    bool DoScanAES();
+    bool DoScanOAV();
+
+    friend unsigned int __stdcall nsDownloadScanner::ScannerThreadFunction(void *);
+  };
+  // Used to give access to Scan
+  friend class nsDownloadScannerWatchdog;
+};
+#endif
+
diff --git a/toolkit/components/downloads/nsIApplicationReputation.idl b/toolkit/components/downloads/nsIApplicationReputation.idl
new file mode 100644
index 000000000..3250cbb75
--- /dev/null
+++ b/toolkit/components/downloads/nsIApplicationReputation.idl
@@ -0,0 +1,122 @@
+/* -*- 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;
+
+/*
+ * 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);
+};
+
+/**
+ * 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 nsIURI referrerURI;
+
+  /*
+   * 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 AString 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 nsIArray of nsIX509CertList of nsIX509Cert that verify for this
+   * binary, if it is signed.
+   */
+  readonly attribute nsIArray 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/downloads/nsIDownload.idl b/toolkit/components/downloads/nsIDownload.idl
new file mode 100644
index 000000000..47eb48780
--- /dev/null
+++ b/toolkit/components/downloads/nsIDownload.idl
@@ -0,0 +1,175 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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 "nsITransfer.idl"
+
+interface nsIURI;
+interface nsIFile;
+interface nsIObserver;
+interface nsICancelable;
+interface nsIWebProgressListener;
+interface nsIMIMEInfo;
+
+/**
+ * Represents a download object.
+ *
+ * @note This object is no longer updated once it enters a completed state.
+ *       Completed states are the following:  
+ *       nsIDownloadManager::DOWNLOAD_FINISHED  
+ *       nsIDownloadManager::DOWNLOAD_FAILED  
+ *       nsIDownloadManager::DOWNLOAD_CANCELED 
+ *       nsIDownloadManager::DOWNLOAD_BLOCKED_PARENTAL 
+ *       nsIDownloadManager::DOWNLOAD_DIRTY 
+ *       nsIDownloadManager::DOWNLOAD_BLOCKED_POLICY 
+ */
+[scriptable, uuid(2258f465-656e-4566-87cb-f791dbaf0322)]
+interface nsIDownload : nsITransfer {
+    
+    /**
+     * The target of a download is always a file on the local file system.
+     */
+    readonly attribute nsIFile targetFile;
+
+    /**
+     * The percentage of transfer completed.
+     * If the file size is unknown it'll be -1 here.
+     */
+    readonly attribute long percentComplete;
+
+    /**
+     * The amount of bytes downloaded so far.
+     */
+    readonly attribute long long amountTransferred;
+
+    /**
+     * The size of file in bytes.
+     * Unknown size is represented by -1.
+     */
+    readonly attribute long long size;
+    
+    /**
+     * The source of the transfer.
+     */
+    readonly attribute nsIURI source;
+    
+    /**
+     * The target of the transfer.
+     */
+    readonly attribute nsIURI target;
+ 
+    /**
+     * Object that can be used to cancel the download.
+     * Will be null after the download is finished.
+     */
+    readonly attribute nsICancelable cancelable;
+
+    /**
+     * The user-readable description of the transfer.
+     */
+    readonly attribute AString displayName;
+
+    /**
+     * The time a transfer was started.
+     */
+    readonly attribute long long startTime;
+
+    /**
+     * The speed of the transfer in bytes/sec.
+     */
+    readonly attribute double speed;
+
+    /**
+     * Optional. If set, it will contain the target's relevant MIME information.
+     * This includes its MIME Type, helper app, and whether that helper should be
+     * executed.
+     */
+    readonly attribute nsIMIMEInfo MIMEInfo;
+
+    /**
+     * The id of the download that is stored in the database - not globally unique.
+     * For example, a private download and a public one might have identical ids.
+     * Can only be safely used for direct database manipulation in the database that
+     * contains this download. Use the guid property instead for safe, database-agnostic
+     * searching and manipulation.
+     *
+     * @deprecated
+     */
+    readonly attribute unsigned long id;
+
+    /**
+     * The guid of the download that is stored in the database.
+     * Has the form of twelve alphanumeric characters.
+     */
+    readonly attribute ACString guid;
+
+    /**
+     * The state of the download.
+     * @see nsIDownloadManager and nsIXPInstallManagerUI
+     */
+    readonly attribute short state;
+
+    /**
+     * The referrer uri of the download.  This is only valid for HTTP downloads,
+     * and can be null.
+     */
+    readonly attribute nsIURI referrer;
+
+    /**
+     * Indicates if the download can be resumed after being paused or not.  This
+     * is only the case if the download is over HTTP/1.1 or FTP and if the
+     * server supports it.
+     */
+    readonly attribute boolean resumable;
+
+    /**
+     * Indicates if the download was initiated from a context marked as private,
+     * controlling whether it should be stored in a permanent manner or not.
+     */
+    readonly attribute boolean isPrivate;
+
+    /**
+     * Cancel this download if it's currently in progress.
+     */
+    void cancel();
+
+    /**
+     * Pause this download if it is in progress.
+     *
+     * @throws NS_ERROR_UNEXPECTED if it cannot be paused.
+     */
+    void pause();
+
+    /**
+     * Resume this download if it is paused.
+     *
+     * @throws NS_ERROR_UNEXPECTED if it cannot be resumed or is not paused.
+     */
+    void resume();
+
+    /**
+     * Instruct the download manager to remove this download. Whereas
+     * cancel simply cancels the transfer, but retains information about it,
+     * remove removes all knowledge of it.
+     *
+     * @see nsIDownloadManager.removeDownload for more detail
+     * @throws NS_ERROR_FAILURE if the download is active.
+     */
+    void remove();
+
+    /**
+     * Instruct the download manager to retry this failed download
+     * @throws NS_ERROR_NOT_AVAILABLE if the download is not known.
+     * @throws NS_ERROR_FAILURE if the download is not in the following states:
+     *         nsIDownloadManager::DOWNLOAD_CANCELED
+     *         nsIDownloadManager::DOWNLOAD_FAILED
+     */
+    void retry();
+};
+
+%{C++
+// {b02be33b-d47c-4bd3-afd9-402a942426b0}
+#define NS_DOWNLOAD_CID \
+  { 0xb02be33b, 0xd47c, 0x4bd3, { 0xaf, 0xd9, 0x40, 0x2a, 0x94, 0x24, 0x26, 0xb0 } }
+%}
diff --git a/toolkit/components/downloads/nsIDownloadManager.idl b/toolkit/components/downloads/nsIDownloadManager.idl
new file mode 100644
index 000000000..d7eba8940
--- /dev/null
+++ b/toolkit/components/downloads/nsIDownloadManager.idl
@@ -0,0 +1,358 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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/. */
+
+// Keeps track of ongoing downloads, in the form of nsIDownload's. 
+
+#include "nsISupports.idl"
+
+interface nsIURI;
+interface nsIFile;
+interface nsIDownload;
+interface nsICancelable;
+interface nsIMIMEInfo;
+interface nsIDownloadProgressListener;
+interface nsISimpleEnumerator;
+interface mozIStorageConnection;
+
+[scriptable, function, uuid(0c07ffeb-791b-49f3-ae38-2c331fd55a52)]
+interface nsIDownloadManagerResult : nsISupports {
+  /**
+   * Process an asynchronous result from getDownloadByGUID.
+   *
+   * @param aStatus The result code of the operation:
+   *        * NS_OK: an item was found. No other success values are returned.
+   *        * NS_ERROR_NOT_AVAILABLE: no such item was found.
+   *        * Other error values are possible, but less well-defined.
+   */
+  void handleResult(in nsresult aStatus, in nsIDownload aDownload);
+};
+
+[scriptable, uuid(b29aac15-7ec4-4ab3-a53b-08f78aed3b34)]
+interface nsIDownloadManager : nsISupports {
+  /**
+   * Download type for generic file download.
+   */
+  const short DOWNLOAD_TYPE_DOWNLOAD = 0;
+
+  /**
+   * Download state for uninitialized download object.
+   */
+  const short DOWNLOAD_NOTSTARTED = -1;
+
+  /**
+   * Download is currently transferring data.
+   */
+  const short DOWNLOAD_DOWNLOADING = 0;
+
+  /**
+   * Download completed including any processing of the target
+   * file.  (completed)
+   */
+  const short DOWNLOAD_FINISHED = 1;
+
+  /**
+   * Transfer failed due to error. (completed)
+   */
+  const short DOWNLOAD_FAILED = 2;
+
+  /**
+   * Download was canceled by the user. (completed)
+   */
+  const short DOWNLOAD_CANCELED = 3;
+
+  /**
+   * Transfer was paused by the user.
+   */
+  const short DOWNLOAD_PAUSED = 4;
+
+  /**
+   * Download is active but data has not yet been received.
+   */
+  const short DOWNLOAD_QUEUED = 5;
+
+  /**
+   * Transfer request was blocked by parental controls proxies. (completed)
+   */
+  const short DOWNLOAD_BLOCKED_PARENTAL = 6;
+
+  /**
+   * Transferred download is being scanned by virus scanners.
+   */
+  const short DOWNLOAD_SCANNING = 7;
+
+  /**
+   * A virus was detected in the download. The target will most likely
+   * no longer exist. (completed)
+   */
+  const short DOWNLOAD_DIRTY = 8;
+
+  /**
+   * Win specific: Request was blocked by zone policy settings.
+   * (see bug #416683) (completed)
+   */
+  const short DOWNLOAD_BLOCKED_POLICY = 9;
+
+
+  /**
+   * Creates an nsIDownload and adds it to be managed by the download manager.
+   *
+   * @param aSource The source URI of the transfer. Must not be null.
+   *
+   * @param aTarget The target URI of the transfer. Must not be null.
+   *
+   * @param aDisplayName The user-readable description of the transfer.
+   *                     Can be empty.
+   *
+   * @param aMIMEInfo The MIME info associated with the target,
+   *                  including MIME type and helper app when appropriate.
+   *                  This parameter is optional.
+   *
+   * @param startTime Time when the download started
+   *
+   * @param aTempFile The location of a temporary file; i.e. a file in which
+   *                  the received data will be stored, but which is not
+   *                  equal to the target file. (will be moved to the real
+   *                  target by the DownloadManager, when the download is
+   *                  finished). This will be null for all callers except for
+   *                  nsExternalHelperAppHandler. Addons should generally pass
+   *                  null for aTempFile. This will be moved to the real target
+   *                  by the download manager when the download is finished,
+   *                  and the action indicated by aMIMEInfo will be executed.
+   *
+   * @param aCancelable An object that can be used to abort the download.
+   *                    Must not be null.
+   *
+   * @param aIsPrivate Used to determine the privacy status of the new download.
+   *                   If true, the download is stored in a manner that leaves
+   *                   no permanent trace outside of the current private session.
+   *
+   * @return The newly created download item with the passed-in properties.
+   *
+   * @note This does not actually start a download.  If you want to add and
+   *       start a download, you need to create an nsIWebBrowserPersist, pass it
+   *       as the aCancelable object, call this method, set the progressListener
+   *       as the returned download object, then call saveURI.
+   */
+  nsIDownload addDownload(in short aDownloadType, 
+                          in nsIURI aSource,
+                          in nsIURI aTarget,
+                          in AString aDisplayName,
+                          in nsIMIMEInfo aMIMEInfo,
+                          in PRTime aStartTime,
+                          in nsIFile aTempFile,
+                          in nsICancelable aCancelable,
+                          in boolean aIsPrivate);
+
+  /**
+   * Retrieves a download managed by the download manager.  This can be one that
+   * is in progress, or one that has completed in the past and is stored in the
+   * database.
+   *
+   * @param aID The unique ID of the download.
+   * @return The download with the specified ID.
+   * @throws NS_ERROR_NOT_AVAILABLE if the download is not in the database.
+   */
+  nsIDownload getDownload(in unsigned long aID);
+
+  /**
+   * Retrieves a download managed by the download manager.  This can be one that
+   * is in progress, or one that has completed in the past and is stored in the
+   * database.  The result of this method is returned via an asynchronous callback,
+   * the parameter of which will be an nsIDownload object, or null if none exists
+   * with the provided GUID.
+   *
+   * @param aGUID The unique GUID of the download.
+   * @param aCallback The callback to invoke with the result of the search.
+   */
+  void getDownloadByGUID(in ACString aGUID, in nsIDownloadManagerResult aCallback);
+
+  /**
+   * Cancels the download with the specified ID if it's currently in-progress.
+   * This calls cancel(NS_BINDING_ABORTED) on the nsICancelable provided by the
+   * download.
+   *
+   * @param aID The unique ID of the download.
+   * @throws NS_ERROR_FAILURE if the download is not in-progress.
+   */
+  void cancelDownload(in unsigned long aID);
+
+  /**
+   * Removes the download with the specified id if it's not currently
+   * in-progress.  Whereas cancelDownload simply cancels the transfer, but
+   * retains information about it, removeDownload removes all knowledge of it.
+   *
+   * Also notifies observers of the "download-manager-remove-download-guid"
+   * topic with the download guid as the subject to allow any DM consumers to
+   * react to the removal.
+   *
+   * Also may notify observers of the "download-manager-remove-download" topic
+   * with the download id as the subject, if the download removed is public
+   * or if global private browsing mode is in use. This notification is deprecated;
+   * the guid notification should be relied upon instead.
+   *
+   * @param aID The unique ID of the download.
+   * @throws NS_ERROR_FAILURE if the download is active.
+   */
+  void removeDownload(in unsigned long aID);
+
+  /**
+   * Removes all inactive downloads that were started inclusively within the
+   * specified time frame.
+   *
+   * @param aBeginTime
+   *        The start time to remove downloads by in microseconds.
+   * @param aEndTime
+   *        The end time to remove downloads by in microseconds.
+   */
+  void removeDownloadsByTimeframe(in long long aBeginTime,
+                                  in long long aEndTime);
+
+  /**
+   * Pause the specified download.
+   *
+   * @param aID The unique ID of the download.
+   * @throws NS_ERROR_FAILURE if the download is not in-progress.
+   */
+  void pauseDownload(in unsigned long aID);
+
+  /**
+   * Resume the specified download.
+   *
+   * @param aID The unique ID of the download.
+   * @throws NS_ERROR_FAILURE if the download is not in-progress.
+   */
+  void resumeDownload(in unsigned long aID);
+
+  /**
+   * Retries a failed download.
+   *
+   * @param aID The unique ID of the download.
+   * @throws NS_ERROR_NOT_AVAILALE if the download id is not known.
+   * @throws NS_ERROR_FAILURE if the download is not in the following states:
+   *           nsIDownloadManager::DOWNLOAD_CANCELED
+   *           nsIDownloadManager::DOWNLOAD_FAILED
+   */
+  void retryDownload(in unsigned long aID);
+
+  /**
+   * The database connection to the downloads database.
+   */
+  readonly attribute mozIStorageConnection DBConnection;
+  readonly attribute mozIStorageConnection privateDBConnection;
+
+  /** 
+   * Whether or not there are downloads that can be cleaned up (removed)
+   * i.e. downloads that have completed, have failed or have been canceled.
+   * In global private browsing mode, this reports the status of the relevant
+   * private or public downloads. In per-window mode, it only reports for
+   * public ones.
+   */
+  readonly attribute boolean canCleanUp;
+
+  /** 
+   * Whether or not there are private downloads that can be cleaned up (removed)
+   * i.e. downloads that have completed, have failed or have been canceled.
+   */
+readonly attribute boolean canCleanUpPrivate;
+
+  /** 
+   * Removes completed, failed, and canceled downloads from the list.
+   * In global private browsing mode, this operates on the relevant
+   * private or public downloads. In per-window mode, it only operates
+   * on public ones.
+   *
+   * Also notifies observers of the "download-manager-remove-download-gui"
+   * and "download-manager-remove-download" topics with a null subject to
+   * allow any DM consumers to react to the removals.
+   */
+  void cleanUp();
+
+  /** 
+   * Removes completed, failed, and canceled downloads from the list
+   * of private downloads.
+   *
+   * Also notifies observers of the "download-manager-remove-download-gui"
+   * and "download-manager-remove-download" topics with a null subject to
+   * allow any DM consumers to react to the removals.
+   */
+void cleanUpPrivate();
+
+  /** 
+   * The number of files currently being downloaded.
+   *
+   * In global private browsing mode, this reports the status of the relevant
+   * private or public downloads. In per-window mode, it only reports public
+   * ones.
+   */
+  readonly attribute long activeDownloadCount;
+
+  /** 
+   * The number of private files currently being downloaded.
+   */
+  readonly attribute long activePrivateDownloadCount;
+
+  /**
+   * An enumeration of active nsIDownloads
+   *
+   * In global private browsing mode, this reports the status of the relevant
+   * private or public downloads. In per-window mode, it only reports public
+   * ones.
+   */
+  readonly attribute nsISimpleEnumerator activeDownloads;
+
+  /**
+   * An enumeration of active private nsIDownloads
+   */
+  readonly attribute nsISimpleEnumerator activePrivateDownloads;
+
+  /**
+   * Adds a listener to the download manager. It is expected that this
+   * listener will only access downloads via their deprecated integer id attribute,
+   * and when global private browsing compatibility mode is disabled, this listener
+   * will receive no notifications for downloads marked private.
+   */
+  void addListener(in nsIDownloadProgressListener aListener);
+
+  /**
+   * Adds a listener to the download manager. This listener must be able to
+   * understand and use the guid attribute of downloads for all interactions
+   * with the download manager.
+   */
+  void addPrivacyAwareListener(in nsIDownloadProgressListener aListener);
+
+  /**
+   * Removes a listener from the download manager.
+   */
+  void removeListener(in nsIDownloadProgressListener aListener);
+
+  /**
+   * Returns the platform default downloads directory.
+   */
+  readonly attribute nsIFile defaultDownloadsDirectory;
+
+  /**
+   * Returns the user configured downloads directory. 
+   * The path is dependent on two user configurable prefs
+   * set in preferences:
+   *
+   * browser.download.folderList
+   *   Indicates the location users wish to save downloaded 
+   *   files too.  
+   *   Values: 
+   *     0 - The desktop is the default download location. 
+   *     1 - The system's downloads folder is the default download location. 
+   *     2 - The default download location is elsewhere as specified in  
+   *         browser.download.dir. If invalid, userDownloadsDirectory
+   *         will fallback on defaultDownloadsDirectory.
+   *
+   * browser.download.dir - 
+   *   A local path the user may have selected at some point 
+   *   where downloaded files are saved. The use of which is
+   *   enabled when folderList equals 2. 
+   */
+  readonly attribute nsIFile userDownloadsDirectory;
+};
+
+
diff --git a/toolkit/components/downloads/nsIDownloadManagerUI.idl b/toolkit/components/downloads/nsIDownloadManagerUI.idl
new file mode 100644
index 000000000..b5ceff5b0
--- /dev/null
+++ b/toolkit/components/downloads/nsIDownloadManagerUI.idl
@@ -0,0 +1,55 @@
+/* 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 nsIInterfaceRequestor;
+interface nsIDownload;
+
+[scriptable, uuid(0c76d4cf-0b06-4c1a-9bea-520c7bbdba99)]
+interface nsIDownloadManagerUI : nsISupports {
+  /**
+   * The reason that should be passed when the user requests to show the
+   * download manager's UI.
+   */
+  const short REASON_USER_INTERACTED = 0;
+
+  /**
+   * The reason that should be passed to the show method when we are displaying
+   * the UI because a new download is being added to it.
+   */
+  const short REASON_NEW_DOWNLOAD = 1;
+
+ /**
+  * Shows the Download Manager's UI to the user.
+  *
+  * @param [optional] aWindowContext
+  *        The parent window context to show the UI.
+  * @param [optional] aDownload
+  *        The download to be preselected upon opening.
+  * @param [optional] aReason
+  *        The reason to show the download manager's UI.  This defaults to
+  *        REASON_USER_INTERACTED, and should be one of the previously listed
+  *        constants.
+  * @param [optional] aUsePrivateUI
+  *        Pass true as this argument to hint to the implementation that it
+  *        should only display private downloads in the UI, if possible.
+  */
+  void show([optional] in nsIInterfaceRequestor aWindowContext,
+            [optional] in nsIDownload aDownload,
+            [optional] in short aReason,
+            [optional] in boolean aUsePrivateUI);
+
+ /**
+  * Indicates if the UI is visible or not.
+  */
+  readonly attribute boolean visible;
+
+ /**
+  * Brings attention to the UI if it is already visible
+  *
+  * @throws NS_ERROR_UNEXPECTED if the UI is not visible.
+  */
+  void getAttention();
+};
+
diff --git a/toolkit/components/downloads/nsIDownloadProgressListener.idl b/toolkit/components/downloads/nsIDownloadProgressListener.idl
new file mode 100644
index 000000000..e406f64d6
--- /dev/null
+++ b/toolkit/components/downloads/nsIDownloadProgressListener.idl
@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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/. */
+
+/* A minimally extended progress listener used by download manager
+ * to update its default UI.  This is implemented in nsDownloadProgressListener.js.
+ * See nsIWebProgressListener for documentation, and use its constants.  This isn't
+ * too pretty, but the alternative is having this extend nsIWebProgressListener and
+ * adding an |item| attribute, which would mean a separate nsIDownloadProgressListener
+ * for every nsIDownloadItem, which is a waste...
+ */
+
+#include "nsISupports.idl"
+
+interface nsIWebProgress;
+interface nsIRequest;
+interface nsIURI;
+interface nsIDownload;
+interface nsIDOMDocument;
+
+[scriptable, uuid(7acb07ea-cac2-4c15-a3ad-23aaa789ed51)]
+interface nsIDownloadProgressListener : nsISupports {
+
+ /**
+  * document
+  * The document of the download manager frontend.
+  */
+  
+  attribute nsIDOMDocument document;
+
+ /**
+  * Dispatched whenever the state of the download changes.
+  *
+  * @param aState The previous download sate.
+  * @param aDownload The download object.
+  * @see nsIDownloadManager for download states.
+  */
+  void onDownloadStateChange(in short aState, in nsIDownload aDownload);
+
+  void onStateChange(in nsIWebProgress aWebProgress,
+                     in nsIRequest aRequest,
+                     in unsigned long aStateFlags,
+                     in nsresult aStatus,
+                     in nsIDownload aDownload);
+
+  void onProgressChange(in nsIWebProgress aWebProgress,
+                        in nsIRequest aRequest,
+                        in long long aCurSelfProgress,
+                        in long long aMaxSelfProgress,
+                        in long long aCurTotalProgress,
+                        in long long aMaxTotalProgress,
+                        in nsIDownload aDownload);
+
+  void onSecurityChange(in nsIWebProgress aWebProgress,
+                        in nsIRequest aRequest,
+                        in unsigned long aState,
+                        in nsIDownload aDownload);
+
+};
diff --git a/toolkit/components/downloads/test/unit/.eslintrc.js b/toolkit/components/downloads/test/unit/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/downloads/test/unit/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/downloads/test/unit/data/block_digest.chunk b/toolkit/components/downloads/test/unit/data/block_digest.chunk
new file mode 100644
index 000000000..34c47c4bb
--- /dev/null
+++ b/toolkit/components/downloads/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/downloads/test/unit/data/digest.chunk b/toolkit/components/downloads/test/unit/data/digest.chunk
new file mode 100644
index 000000000..b1fbb4667
--- /dev/null
+++ b/toolkit/components/downloads/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/downloads/test/unit/data/signed_win.exe b/toolkit/components/downloads/test/unit/data/signed_win.exe
new file mode 100644
index 000000000..de3bb40e8
--- /dev/null
+++ b/toolkit/components/downloads/test/unit/data/signed_win.exe
diff --git a/toolkit/components/downloads/test/unit/head_download_manager.js b/toolkit/components/downloads/test/unit/head_download_manager.js
new file mode 100644
index 000000000..1e8248071
--- /dev/null
+++ b/toolkit/components/downloads/test/unit/head_download_manager.js
@@ -0,0 +1,26 @@
+/* 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
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cu = Components.utils;
+var Cr = Components.results;
+
+do_get_profile();
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://testing-common/httpd.js");
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+                                  "resource://gre/modules/Promise.jsm");
+
+function createURI(aObj)
+{
+  var ios = Cc["@mozilla.org/network/io-service;1"].
+            getService(Ci.nsIIOService);
+  return (aObj instanceof Ci.nsIFile) ? ios.newFileURI(aObj) :
+                                        ios.newURI(aObj, null, null);
+}
diff --git a/toolkit/components/downloads/test/unit/tail_download_manager.js b/toolkit/components/downloads/test/unit/tail_download_manager.js
new file mode 100644
index 000000000..4043f31b9
--- /dev/null
+++ b/toolkit/components/downloads/test/unit/tail_download_manager.js
@@ -0,0 +1,23 @@
+/* -*- 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/. */
+
+/**
+ * Provides infrastructure for automated download components tests.
+ */
+
+"use strict";
+
+// Termination functions common to all tests
+
+add_task(function* test_common_terminate()
+{
+  // Stop the HTTP server.  We must do this inside a task in "tail.js" until the
+  // xpcshell testing framework supports asynchronous termination functions.
+  let deferred = Promise.defer();
+  gHttpServer.stop(deferred.resolve);
+  yield deferred.promise;
+});
+
diff --git a/toolkit/components/downloads/test/unit/test_app_rep.js b/toolkit/components/downloads/test/unit/test_app_rep.js
new file mode 100644
index 000000000..636a71e78
--- /dev/null
+++ b/toolkit/components/downloads/test/unit/test_app_rep.js
@@ -0,0 +1,342 @@
+/* -*- 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/. */
+
+Cu.import('resource://gre/modules/NetUtil.jsm');
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+const gAppRep = Cc["@mozilla.org/downloads/application-reputation-service;1"].
+                  getService(Ci.nsIApplicationReputationService);
+var gHttpServ = null;
+var gTables = {};
+
+var ALLOW_LIST = 0;
+var BLOCK_LIST = 1;
+var NO_LIST = 2;
+
+var whitelistedURI = createURI("http://foo:bar@whitelisted.com/index.htm#junk");
+var exampleURI = createURI("http://user:password@example.com/i.html?foo=bar");
+var blocklistedURI = createURI("http://baz:qux@blocklisted.com?xyzzy");
+
+const appRepURLPref = "browser.safebrowsing.downloads.remote.url";
+
+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) {
+    do_print("Mock safebrowsing server handling request for " + redirectPath);
+    let contents = readFileToString(aFilename);
+    do_print("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(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);
+  do_register_cleanup(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");
+  do_register_cleanup(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) {
+    do_throw("This test should never make a remote lookup");
+  });
+  gHttpServ.start(4444);
+});
+
+function run_test() {
+  run_next_test();
+}
+
+function check_telemetry(aCount,
+                         aShouldBlockCount,
+                         aListCounts) {
+  let count = Cc["@mozilla.org/base/telemetry;1"]
+                .getService(Ci.nsITelemetry)
+                .getHistogramById("APPLICATION_REPUTATION_COUNT")
+                .snapshot();
+  do_check_eq(count.counts[1], aCount);
+  let local = Cc["@mozilla.org/base/telemetry;1"]
+                .getService(Ci.nsITelemetry)
+                .getHistogramById("APPLICATION_REPUTATION_LOCAL")
+                .snapshot();
+  do_check_eq(local.counts[ALLOW_LIST], aListCounts[ALLOW_LIST],
+              "Allow list counts don't match");
+  do_check_eq(local.counts[BLOCK_LIST], aListCounts[BLOCK_LIST],
+              "Block list counts don't match");
+  do_check_eq(local.counts[NO_LIST], aListCounts[NO_LIST],
+              "No list counts don't match");
+
+  let shouldBlock = Cc["@mozilla.org/base/telemetry;1"]
+                .getService(Ci.nsITelemetry)
+                .getHistogramById("APPLICATION_REPUTATION_SHOULD_BLOCK")
+                .snapshot();
+  // SHOULD_BLOCK = true
+  do_check_eq(shouldBlock.counts[1], aShouldBlockCount);
+  // Sanity check that SHOULD_BLOCK total adds up to the COUNT.
+  do_check_eq(shouldBlock.counts[0] + shouldBlock.counts[1], aCount);
+}
+
+function get_telemetry_counts() {
+  let count = Cc["@mozilla.org/base/telemetry;1"]
+                .getService(Ci.nsITelemetry)
+                .getHistogramById("APPLICATION_REPUTATION_COUNT")
+                .snapshot();
+  let local = Cc["@mozilla.org/base/telemetry;1"]
+                .getService(Ci.nsITelemetry)
+                .getHistogramById("APPLICATION_REPUTATION_LOCAL")
+                .snapshot();
+  let shouldBlock = Cc["@mozilla.org/base/telemetry;1"]
+                .getService(Ci.nsITelemetry)
+                .getHistogramById("APPLICATION_REPUTATION_SHOULD_BLOCK")
+                .snapshot();
+  return { total: count.counts[1],
+           shouldBlock: shouldBlock.counts[1],
+           listCounts: local.counts };
+}
+
+add_test(function test_nullSourceURI() {
+  let counts = get_telemetry_counts();
+  gAppRep.queryReputation({
+    // No source URI
+    fileSize: 12,
+  }, function onComplete(aShouldBlock, aStatus) {
+    do_check_eq(Cr.NS_ERROR_UNEXPECTED, aStatus);
+    do_check_false(aShouldBlock);
+    check_telemetry(counts.total + 1, counts.shouldBlock, counts.listCounts);
+    run_next_test();
+  });
+});
+
+add_test(function test_nullCallback() {
+  let counts = get_telemetry_counts();
+  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(counts.total, counts.shouldBlock, counts.listCounts);
+    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";
+      }
+    }
+    do_print("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.
+    do_check_eq("1000", aEvent);
+    do_print("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 counts = get_telemetry_counts();
+  let listCounts = counts.listCounts;
+  listCounts[NO_LIST]++;
+  gAppRep.queryReputation({
+    sourceURI: exampleURI,
+    fileSize: 12,
+  }, function onComplete(aShouldBlock, aStatus) {
+    do_check_eq(Cr.NS_OK, aStatus);
+    do_check_false(aShouldBlock);
+    check_telemetry(counts.total + 1, counts.shouldBlock, listCounts);
+    run_next_test();
+  });
+});
+
+add_test(function test_non_uri() {
+  Services.prefs.setCharPref(appRepURLPref,
+                             "http://localhost:4444/download");
+  let counts = get_telemetry_counts();
+  let listCounts = counts.listCounts;
+  // No listcount is incremented, since the sourceURI is not an nsIURL
+  let source = NetUtil.newURI("data:application/octet-stream,ABC");
+  do_check_false(source instanceof Ci.nsIURL);
+  gAppRep.queryReputation({
+    sourceURI: source,
+    fileSize: 12,
+  }, function onComplete(aShouldBlock, aStatus) {
+    do_check_eq(Cr.NS_OK, aStatus);
+    do_check_false(aShouldBlock);
+    check_telemetry(counts.total + 1, counts.shouldBlock, listCounts);
+    run_next_test();
+  });
+});
+
+add_test(function test_local_blacklist() {
+  Services.prefs.setCharPref(appRepURLPref,
+                             "http://localhost:4444/download");
+  let counts = get_telemetry_counts();
+  let listCounts = counts.listCounts;
+  listCounts[BLOCK_LIST]++;
+  gAppRep.queryReputation({
+    sourceURI: blocklistedURI,
+    fileSize: 12,
+  }, function onComplete(aShouldBlock, aStatus) {
+    do_check_eq(Cr.NS_OK, aStatus);
+    do_check_true(aShouldBlock);
+    check_telemetry(counts.total + 1, counts.shouldBlock + 1, listCounts);
+    run_next_test();
+  });
+});
+
+add_test(function test_referer_blacklist() {
+  Services.prefs.setCharPref(appRepURLPref,
+                             "http://localhost:4444/download");
+  let counts = get_telemetry_counts();
+  let listCounts = counts.listCounts;
+  listCounts[BLOCK_LIST]++;
+  gAppRep.queryReputation({
+    sourceURI: exampleURI,
+    referrerURI: blocklistedURI,
+    fileSize: 12,
+  }, function onComplete(aShouldBlock, aStatus) {
+    do_check_eq(Cr.NS_OK, aStatus);
+    do_check_true(aShouldBlock);
+    check_telemetry(counts.total + 1, counts.shouldBlock + 1, listCounts);
+    run_next_test();
+  });
+});
+
+add_test(function test_blocklist_trumps_allowlist() {
+  Services.prefs.setCharPref(appRepURLPref,
+                             "http://localhost:4444/download");
+  let counts = get_telemetry_counts();
+  let listCounts = counts.listCounts;
+  listCounts[BLOCK_LIST]++;
+  gAppRep.queryReputation({
+    sourceURI: whitelistedURI,
+    referrerURI: blocklistedURI,
+    fileSize: 12,
+  }, function onComplete(aShouldBlock, aStatus) {
+    do_check_eq(Cr.NS_OK, aStatus);
+    do_check_true(aShouldBlock);
+    check_telemetry(counts.total + 1, counts.shouldBlock + 1, listCounts);
+    run_next_test();
+  });
+});
+
+add_test(function test_redirect_on_blocklist() {
+  Services.prefs.setCharPref(appRepURLPref,
+                             "http://localhost:4444/download");
+  let counts = get_telemetry_counts();
+  let listCounts = counts.listCounts;
+  listCounts[BLOCK_LIST]++;
+  listCounts[ALLOW_LIST]++;
+  let secman = Services.scriptSecurityManager;
+  let badRedirects = Cc["@mozilla.org/array;1"]
+                       .createInstance(Ci.nsIMutableArray);
+  badRedirects.appendElement(secman.createCodebasePrincipal(exampleURI, {}),
+                             false);
+  badRedirects.appendElement(secman.createCodebasePrincipal(blocklistedURI, {}),
+                             false);
+  badRedirects.appendElement(secman.createCodebasePrincipal(whitelistedURI, {}),
+                             false);
+  gAppRep.queryReputation({
+    sourceURI: whitelistedURI,
+    referrerURI: exampleURI,
+    redirects: badRedirects,
+    fileSize: 12,
+  }, function onComplete(aShouldBlock, aStatus) {
+    do_check_eq(Cr.NS_OK, aStatus);
+    do_check_true(aShouldBlock);
+    check_telemetry(counts.total + 1, counts.shouldBlock + 1, listCounts);
+    run_next_test();
+  });
+});
diff --git a/toolkit/components/downloads/test/unit/test_app_rep_maclinux.js b/toolkit/components/downloads/test/unit/test_app_rep_maclinux.js
new file mode 100644
index 000000000..7f94d1520
--- /dev/null
+++ b/toolkit/components/downloads/test/unit/test_app_rep_maclinux.js
@@ -0,0 +1,303 @@
+/* -*- 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
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
+                                  "resource://gre/modules/NetUtil.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+                                  "resource://gre/modules/Promise.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Task",
+                                  "resource://gre/modules/Task.jsm");
+
+const gAppRep = Cc["@mozilla.org/downloads/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) {
+    do_print("Mock safebrowsing server handling request for " + redirectPath);
+    let contents = readFileToString(aFilename);
+    do_print("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
+
+function run_test()
+{
+  run_next_test();
+}
+
+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 locale = Services.prefs.getCharPref("general.useragent.locale");
+  Services.prefs.setCharPref("general.useragent.locale", "en-US");
+
+  do_register_cleanup(function() {
+    Services.prefs.clearUserPref("browser.safebrowsing.malware.enabled");
+    Services.prefs.clearUserPref("browser.safebrowsing.downloads.enabled");
+    Services.prefs.clearUserPref("urlclassifier.downloadBlockTable");
+    Services.prefs.setCharPref("general.useragent.locale", locale);
+  });
+
+  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) {
+    do_print("Querying remote server for verdict");
+    response.setHeader("Content-Type", "application/octet-stream", false);
+    let buf = NetUtil.readInputStreamToString(
+      request.bodyInputStream,
+      request.bodyInputStream.available());
+    do_print("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);
+});
+
+// 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";
+    }
+  }
+  do_print("Returning update response: " + response);
+  return response;
+}
+
+// Set up the local whitelist.
+function waitForUpdates() {
+  let deferred = Promise.defer();
+  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.
+    do_check_eq("1000", aEvent);
+    do_print("All data processed");
+    deferred.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);
+    deferred.reject();
+  }
+  streamUpdater.downloadUpdates(
+    "goog-downloadwhite-digest256",
+    "goog-downloadwhite-digest256;\n",
+    true,
+    "http://localhost:4444/downloads",
+    updateSuccess, handleError, handleError);
+  return deferred.promise;
+}
+
+function promiseQueryReputation(query, expectedShouldBlock) {
+  let deferred = Promise.defer();
+  function onComplete(aShouldBlock, aStatus) {
+    do_check_eq(Cr.NS_OK, aStatus);
+    do_check_eq(aShouldBlock, expectedShouldBlock);
+    deferred.resolve(true);
+  }
+  gAppRep.queryReputation(query, onComplete);
+  return deferred.promise;
+}
+
+add_task(function* ()
+{
+  // Wait for Safebrowsing local list updates to complete.
+  yield waitForUpdates();
+});
+
+add_task(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");
+  // evil.com should return a malware verdict from the remote server.
+  yield promiseQueryReputation({sourceURI: createURI("http://evil.com"),
+                                suggestedFileName: "noop.bat",
+                                fileSize: 12}, true);
+});
+
+add_task(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");
+  yield promiseQueryReputation({sourceURI: createURI("http://evil.com"),
+                                suggestedFileName: "noop.txt",
+                                fileSize: 12}, false);
+});
+
+add_task(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");
+  // mozilla.com should return a not-guilty verdict from the remote server.
+  yield promiseQueryReputation({sourceURI: createURI("http://mozilla.com"),
+                                suggestedFileName: "noop.bat",
+                                fileSize: 12}, false);
+});
+
+add_task(function* test_disabled()
+{
+  // Explicitly disable remote checks
+  Services.prefs.setBoolPref(remoteEnabledPref,
+                             false);
+  Services.prefs.setCharPref(appRepURLPref,
+                             "http://localhost:4444/throw");
+  let query = {sourceURI: createURI("http://example.com"),
+               suggestedFileName: "noop.bat",
+               fileSize: 12};
+  let deferred = Promise.defer();
+  gAppRep.queryReputation(query,
+    function onComplete(aShouldBlock, aStatus) {
+      // We should be getting NS_ERROR_NOT_AVAILABLE if the service is disabled
+      do_check_eq(Cr.NS_ERROR_NOT_AVAILABLE, aStatus);
+      do_check_false(aShouldBlock);
+      deferred.resolve(true);
+    }
+  );
+  yield deferred.promise;
+});
+
+add_task(function* test_disabled_through_lists()
+{
+  Services.prefs.setBoolPref(remoteEnabledPref,
+                             false);
+  Services.prefs.setCharPref(appRepURLPref,
+                             "http://localhost:4444/download");
+  Services.prefs.setCharPref("urlclassifier.downloadBlockTable", "");
+  let query = {sourceURI: createURI("http://example.com"),
+               suggestedFileName: "noop.bat",
+               fileSize: 12};
+  let deferred = Promise.defer();
+  gAppRep.queryReputation(query,
+    function onComplete(aShouldBlock, aStatus) {
+      // We should be getting NS_ERROR_NOT_AVAILABLE if the service is disabled
+      do_check_eq(Cr.NS_ERROR_NOT_AVAILABLE, aStatus);
+      do_check_false(aShouldBlock);
+      deferred.resolve(true);
+    }
+  );
+  yield deferred.promise;
+});
+add_task(function* test_teardown()
+{
+  gStillRunning = false;
+});
diff --git a/toolkit/components/downloads/test/unit/test_app_rep_windows.js b/toolkit/components/downloads/test/unit/test_app_rep_windows.js
new file mode 100644
index 000000000..4ff772e61
--- /dev/null
+++ b/toolkit/components/downloads/test/unit/test_app_rep_windows.js
@@ -0,0 +1,434 @@
+/* -*- 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
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "FileUtils",
+                                  "resource://gre/modules/FileUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
+                                  "resource://gre/modules/NetUtil.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+                                  "resource://gre/modules/Promise.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Task",
+                                  "resource://gre/modules/Task.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/downloads/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";
+
+/**
+ * Returns a reference to a temporary file.  If the file is then created, it
+ * will be removed when tests in this file finish.
+ */
+function getTempFile(aLeafName) {
+  let file = FileUtils.getFile("TmpD", [aLeafName]);
+  do_register_cleanup(function GTF_cleanup() {
+    if (file.exists()) {
+      file.remove(false);
+    }
+  });
+  return file;
+}
+
+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) {
+  let deferred = Promise.defer();
+  aSaver.observer = {
+    onTargetChange: function BFSO_onSaveComplete(unused, aTarget)
+    {
+      if (aOnTargetChangeFn) {
+        aOnTargetChangeFn(aTarget);
+      }
+    },
+    onSaveComplete: function BFSO_onSaveComplete(unused, aStatus)
+    {
+      if (Components.isSuccessCode(aStatus)) {
+        deferred.resolve();
+      } else {
+        deferred.reject(new Components.Exception("Saver failed.", aStatus));
+      }
+    },
+  };
+  return deferred.promise;
+}
+
+/**
+ * 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) {
+  let deferred = Promise.defer();
+  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: function () { },
+    onStopRequest: function (aRequest, aContext, aStatusCode)
+    {
+      if (Components.isSuccessCode(aStatusCode)) {
+        deferred.resolve();
+      } else {
+        deferred.reject(new Components.Exception(aResult));
+      }
+    },
+  }, null);
+  return deferred.promise;
+}
+
+// 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) {
+    do_print("Mock safebrowsing server handling request for " + redirectPath);
+    let contents = readFileToString(aFilename);
+    do_print("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
+
+function run_test()
+{
+  run_next_test();
+}
+
+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 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 locale = Services.prefs.getCharPref("general.useragent.locale");
+  Services.prefs.setCharPref("general.useragent.locale", "en-US");
+
+  do_register_cleanup(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.prefs.setCharPref("general.useragent.locale", locale);
+  });
+
+  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) {
+    do_print("Querying remote server for verdict");
+    response.setHeader("Content-Type", "application/octet-stream", false);
+    let buf = NetUtil.readInputStreamToString(
+      request.bodyInputStream,
+      request.bodyInputStream.available());
+    do_print("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);
+});
+
+// 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";
+    }
+  }
+  do_print("Returning update response: " + response);
+  return response;
+}
+
+// Set up the local whitelist.
+function waitForUpdates() {
+  let deferred = Promise.defer();
+  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.
+    do_check_eq("1000", aEvent);
+    do_print("All data processed");
+    deferred.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);
+    deferred.reject();
+  }
+  streamUpdater.downloadUpdates(
+    "goog-downloadwhite-digest256",
+    "goog-downloadwhite-digest256;\n",
+    true,
+    "http://localhost:4444/downloads",
+    updateSuccess, handleError, handleError);
+  return deferred.promise;
+}
+
+function promiseQueryReputation(query, expectedShouldBlock) {
+  let deferred = Promise.defer();
+  function onComplete(aShouldBlock, aStatus) {
+    do_check_eq(Cr.NS_OK, aStatus);
+    do_check_eq(aShouldBlock, expectedShouldBlock);
+    deferred.resolve(true);
+  }
+  gAppRep.queryReputation(query, onComplete);
+  return deferred.promise;
+}
+
+add_task(function* ()
+{
+  // Wait for Safebrowsing local list updates to complete.
+  yield waitForUpdates();
+});
+
+add_task(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");
+
+  // Use BackgroundFileSaver to extract the signature on Windows.
+  let destFile = 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);
+  yield promiseCopyToSaver(data, saver, true);
+
+  saver.finish(Cr.NS_OK);
+  yield 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.
+  yield promiseQueryReputation({sourceURI: createURI("http://evil.com"),
+                                signatureInfo: saver.signatureInfo,
+                                fileSize: 12}, false);
+});
+
+add_task(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");
+  // evil.com should return a malware verdict from the remote server.
+  yield promiseQueryReputation({sourceURI: createURI("http://evil.com"),
+                                suggestedFileName: "noop.bat",
+                                fileSize: 12}, true);
+});
+
+add_task(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");
+  yield promiseQueryReputation({sourceURI: createURI("http://evil.com"),
+                                suggestedFileName: "noop.txt",
+                                fileSize: 12}, false);
+});
+
+add_task(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");
+  // mozilla.com should return a not-guilty verdict from the remote server.
+  yield promiseQueryReputation({sourceURI: createURI("http://mozilla.com"),
+                                suggestedFileName: "noop.bat",
+                                fileSize: 12}, false);
+});
+
+add_task(function* test_disabled()
+{
+  // Explicitly disable remote checks
+  Services.prefs.setBoolPref(remoteEnabledPref,
+                             false);
+  Services.prefs.setCharPref(appRepURLPref,
+                             "http://localhost:4444/throw");
+  let query = {sourceURI: createURI("http://example.com"),
+               suggestedFileName: "noop.bat",
+               fileSize: 12};
+  let deferred = Promise.defer();
+  gAppRep.queryReputation(query,
+    function onComplete(aShouldBlock, aStatus) {
+      // We should be getting NS_ERROR_NOT_AVAILABLE if the service is disabled
+      do_check_eq(Cr.NS_ERROR_NOT_AVAILABLE, aStatus);
+      do_check_false(aShouldBlock);
+      deferred.resolve(true);
+    }
+  );
+  yield deferred.promise;
+});
+
+add_task(function* test_disabled_through_lists()
+{
+  Services.prefs.setBoolPref(remoteEnabledPref,
+                             false);
+  Services.prefs.setCharPref(appRepURLPref,
+                             "http://localhost:4444/download");
+  Services.prefs.setCharPref("urlclassifier.downloadBlockTable", "");
+  let query = {sourceURI: createURI("http://example.com"),
+               suggestedFileName: "noop.bat",
+               fileSize: 12};
+  let deferred = Promise.defer();
+  gAppRep.queryReputation(query,
+    function onComplete(aShouldBlock, aStatus) {
+      // We should be getting NS_ERROR_NOT_AVAILABLE if the service is disabled
+      do_check_eq(Cr.NS_ERROR_NOT_AVAILABLE, aStatus);
+      do_check_false(aShouldBlock);
+      deferred.resolve(true);
+    }
+  );
+  yield deferred.promise;
+});
+add_task(function* test_teardown()
+{
+  gStillRunning = false;
+});
diff --git a/toolkit/components/downloads/test/unit/xpcshell.ini b/toolkit/components/downloads/test/unit/xpcshell.ini
new file mode 100644
index 000000000..68b6e1fc3
--- /dev/null
+++ b/toolkit/components/downloads/test/unit/xpcshell.ini
@@ -0,0 +1,14 @@
+[DEFAULT]
+head = head_download_manager.js
+tail = tail_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"