The Tor Browser: toolkit/components/downloads/csd.pb.h@925c144e1f1f

     1 // Generated by the protocol buffer compiler.  DO NOT EDIT!

     2 // source: csd.proto

     4 #ifndef PROTOBUF_csd_2eproto__INCLUDED

     5 #define PROTOBUF_csd_2eproto__INCLUDED

     7 #include <string>

     9 #include <google/protobuf/stubs/common.h>

    11 #if GOOGLE_PROTOBUF_VERSION < 2004000

    12 #error This file was generated by a newer version of protoc which is

    13 #error incompatible with your Protocol Buffer headers.  Please update

    14 #error your headers.

    15 #endif

    16 #if 2004001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION

    17 #error This file was generated by an older version of protoc which is

    18 #error incompatible with your Protocol Buffer headers.  Please

    19 #error regenerate this file with a newer version of protoc.

    20 #endif

    22 #include <google/protobuf/generated_message_util.h>

    23 #include <google/protobuf/repeated_field.h>

    24 #include <google/protobuf/extension_set.h>

    25 // @@protoc_insertion_point(includes)

    27 namespace safe_browsing {

    29 // Internal implementation detail -- do not call these.

    30 void  protobuf_AddDesc_csd_2eproto();

    31 void protobuf_AssignDesc_csd_2eproto();

    32 void protobuf_ShutdownFile_csd_2eproto();

    34 class ClientPhishingRequest;

    35 class ClientPhishingRequest_Feature;

    36 class ClientPhishingResponse;

    37 class ClientMalwareRequest;

    38 class ClientMalwareRequest_Feature;

    39 class ClientMalwareResponse;

    40 class ClientDownloadRequest;

    41 class ClientDownloadRequest_Digests;

    42 class ClientDownloadRequest_Resource;

    43 class ClientDownloadRequest_CertificateChain;

    44 class ClientDownloadRequest_CertificateChain_Element;

    45 class ClientDownloadRequest_SignatureInfo;

    46 class ClientDownloadResponse;

    47 class ClientDownloadResponse_MoreInfo;

    48 class ClientDownloadReport;

    49 class ClientDownloadReport_UserInformation;

    50 class ClientUploadResponse;

    52 enum ClientDownloadRequest_ResourceType {

    53   ClientDownloadRequest_ResourceType_DOWNLOAD_URL = 0,

    54   ClientDownloadRequest_ResourceType_DOWNLOAD_REDIRECT = 1,

    55   ClientDownloadRequest_ResourceType_TAB_URL = 2,

    56   ClientDownloadRequest_ResourceType_TAB_REDIRECT = 3

    57 };

    58 bool ClientDownloadRequest_ResourceType_IsValid(int value);

    59 const ClientDownloadRequest_ResourceType ClientDownloadRequest_ResourceType_ResourceType_MIN = ClientDownloadRequest_ResourceType_DOWNLOAD_URL;

    60 const ClientDownloadRequest_ResourceType ClientDownloadRequest_ResourceType_ResourceType_MAX = ClientDownloadRequest_ResourceType_TAB_REDIRECT;

    61 const int ClientDownloadRequest_ResourceType_ResourceType_ARRAYSIZE = ClientDownloadRequest_ResourceType_ResourceType_MAX + 1;

    63 enum ClientDownloadRequest_DownloadType {

    64   ClientDownloadRequest_DownloadType_WIN_EXECUTABLE = 0,

    65   ClientDownloadRequest_DownloadType_CHROME_EXTENSION = 1,

    66   ClientDownloadRequest_DownloadType_ANDROID_APK = 2,

    67   ClientDownloadRequest_DownloadType_ZIPPED_EXECUTABLE = 3

    68 };

    69 bool ClientDownloadRequest_DownloadType_IsValid(int value);

    70 const ClientDownloadRequest_DownloadType ClientDownloadRequest_DownloadType_DownloadType_MIN = ClientDownloadRequest_DownloadType_WIN_EXECUTABLE;

    71 const ClientDownloadRequest_DownloadType ClientDownloadRequest_DownloadType_DownloadType_MAX = ClientDownloadRequest_DownloadType_ZIPPED_EXECUTABLE;

    72 const int ClientDownloadRequest_DownloadType_DownloadType_ARRAYSIZE = ClientDownloadRequest_DownloadType_DownloadType_MAX + 1;

    74 enum ClientDownloadResponse_Verdict {

    75   ClientDownloadResponse_Verdict_SAFE = 0,

    76   ClientDownloadResponse_Verdict_DANGEROUS = 1,

    77   ClientDownloadResponse_Verdict_UNCOMMON = 2,

    78   ClientDownloadResponse_Verdict_POTENTIALLY_UNWANTED = 3,

    79   ClientDownloadResponse_Verdict_DANGEROUS_HOST = 4

    80 };

    81 bool ClientDownloadResponse_Verdict_IsValid(int value);

    82 const ClientDownloadResponse_Verdict ClientDownloadResponse_Verdict_Verdict_MIN = ClientDownloadResponse_Verdict_SAFE;

    83 const ClientDownloadResponse_Verdict ClientDownloadResponse_Verdict_Verdict_MAX = ClientDownloadResponse_Verdict_DANGEROUS_HOST;

    84 const int ClientDownloadResponse_Verdict_Verdict_ARRAYSIZE = ClientDownloadResponse_Verdict_Verdict_MAX + 1;

    86 enum ClientDownloadReport_Reason {

    87   ClientDownloadReport_Reason_SHARE = 0,

    88   ClientDownloadReport_Reason_FALSE_POSITIVE = 1,

    89   ClientDownloadReport_Reason_APPEAL = 2

    90 };

    91 bool ClientDownloadReport_Reason_IsValid(int value);

    92 const ClientDownloadReport_Reason ClientDownloadReport_Reason_Reason_MIN = ClientDownloadReport_Reason_SHARE;

    93 const ClientDownloadReport_Reason ClientDownloadReport_Reason_Reason_MAX = ClientDownloadReport_Reason_APPEAL;

    94 const int ClientDownloadReport_Reason_Reason_ARRAYSIZE = ClientDownloadReport_Reason_Reason_MAX + 1;

    96 enum ClientUploadResponse_UploadStatus {

    97   ClientUploadResponse_UploadStatus_SUCCESS = 0,

    98   ClientUploadResponse_UploadStatus_UPLOAD_FAILURE = 1

    99 };

   100 bool ClientUploadResponse_UploadStatus_IsValid(int value);

   101 const ClientUploadResponse_UploadStatus ClientUploadResponse_UploadStatus_UploadStatus_MIN = ClientUploadResponse_UploadStatus_SUCCESS;

   102 const ClientUploadResponse_UploadStatus ClientUploadResponse_UploadStatus_UploadStatus_MAX = ClientUploadResponse_UploadStatus_UPLOAD_FAILURE;

   103 const int ClientUploadResponse_UploadStatus_UploadStatus_ARRAYSIZE = ClientUploadResponse_UploadStatus_UploadStatus_MAX + 1;

   105 // ===================================================================

   107 class ClientPhishingRequest_Feature : public ::google::protobuf::MessageLite {

   108  public:

   109   ClientPhishingRequest_Feature();

   110   virtual ~ClientPhishingRequest_Feature();

   112   ClientPhishingRequest_Feature(const ClientPhishingRequest_Feature& from);

   114   inline ClientPhishingRequest_Feature& operator=(const ClientPhishingRequest_Feature& from) {

   115     CopyFrom(from);

   116     return *this;

   117   }

   119   static const ClientPhishingRequest_Feature& default_instance();

   121   void Swap(ClientPhishingRequest_Feature* other);

   123   // implements Message ----------------------------------------------

   125   ClientPhishingRequest_Feature* New() const;

   126   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

   127   void CopyFrom(const ClientPhishingRequest_Feature& from);

   128   void MergeFrom(const ClientPhishingRequest_Feature& from);

   129   void Clear();

   130   bool IsInitialized() const;

   132   int ByteSize() const;

   133   bool MergePartialFromCodedStream(

   134       ::google::protobuf::io::CodedInputStream* input);

   135   void SerializeWithCachedSizes(

   136       ::google::protobuf::io::CodedOutputStream* output) const;

   137   int GetCachedSize() const { return _cached_size_; }

   138   private:

   139   void SharedCtor();

   140   void SharedDtor();

   141   void SetCachedSize(int size) const;

   142   public:

   144   ::std::string GetTypeName() const;

   146   // nested types ----------------------------------------------------

   148   // accessors -------------------------------------------------------

   150   // required string name = 1;

   151   inline bool has_name() const;

   152   inline void clear_name();

   153   static const int kNameFieldNumber = 1;

   154   inline const ::std::string& name() const;

   155   inline void set_name(const ::std::string& value);

   156   inline void set_name(const char* value);

   157   inline void set_name(const char* value, size_t size);

   158   inline ::std::string* mutable_name();

   159   inline ::std::string* release_name();

   161   // required double value = 2;

   162   inline bool has_value() const;

   163   inline void clear_value();

   164   static const int kValueFieldNumber = 2;

   165   inline double value() const;

   166   inline void set_value(double value);

   168   // @@protoc_insertion_point(class_scope:safe_browsing.ClientPhishingRequest.Feature)

   169  private:

   170   inline void set_has_name();

   171   inline void clear_has_name();

   172   inline void set_has_value();

   173   inline void clear_has_value();

   175   ::std::string* name_;

   176   double value_;

   178   mutable int _cached_size_;

   179   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

   181   friend void  protobuf_AddDesc_csd_2eproto();

   182   friend void protobuf_AssignDesc_csd_2eproto();

   183   friend void protobuf_ShutdownFile_csd_2eproto();

   185   void InitAsDefaultInstance();

   186   static ClientPhishingRequest_Feature* default_instance_;

   187 };

   188 // -------------------------------------------------------------------

   190 class ClientPhishingRequest : public ::google::protobuf::MessageLite {

   191  public:

   192   ClientPhishingRequest();

   193   virtual ~ClientPhishingRequest();

   195   ClientPhishingRequest(const ClientPhishingRequest& from);

   197   inline ClientPhishingRequest& operator=(const ClientPhishingRequest& from) {

   198     CopyFrom(from);

   199     return *this;

   200   }

   202   static const ClientPhishingRequest& default_instance();

   204   void Swap(ClientPhishingRequest* other);

   206   // implements Message ----------------------------------------------

   208   ClientPhishingRequest* New() const;

   209   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

   210   void CopyFrom(const ClientPhishingRequest& from);

   211   void MergeFrom(const ClientPhishingRequest& from);

   212   void Clear();

   213   bool IsInitialized() const;

   215   int ByteSize() const;

   216   bool MergePartialFromCodedStream(

   217       ::google::protobuf::io::CodedInputStream* input);

   218   void SerializeWithCachedSizes(

   219       ::google::protobuf::io::CodedOutputStream* output) const;

   220   int GetCachedSize() const { return _cached_size_; }

   221   private:

   222   void SharedCtor();

   223   void SharedDtor();

   224   void SetCachedSize(int size) const;

   225   public:

   227   ::std::string GetTypeName() const;

   229   // nested types ----------------------------------------------------

   231   typedef ClientPhishingRequest_Feature Feature;

   233   // accessors -------------------------------------------------------

   235   // optional string url = 1;

   236   inline bool has_url() const;

   237   inline void clear_url();

   238   static const int kUrlFieldNumber = 1;

   239   inline const ::std::string& url() const;

   240   inline void set_url(const ::std::string& value);

   241   inline void set_url(const char* value);

   242   inline void set_url(const char* value, size_t size);

   243   inline ::std::string* mutable_url();

   244   inline ::std::string* release_url();

   246   // optional bytes OBSOLETE_hash_prefix = 10;

   247   inline bool has_obsolete_hash_prefix() const;

   248   inline void clear_obsolete_hash_prefix();

   249   static const int kOBSOLETEHashPrefixFieldNumber = 10;

   250   inline const ::std::string& obsolete_hash_prefix() const;

   251   inline void set_obsolete_hash_prefix(const ::std::string& value);

   252   inline void set_obsolete_hash_prefix(const char* value);

   253   inline void set_obsolete_hash_prefix(const void* value, size_t size);

   254   inline ::std::string* mutable_obsolete_hash_prefix();

   255   inline ::std::string* release_obsolete_hash_prefix();

   257   // required float client_score = 2;

   258   inline bool has_client_score() const;

   259   inline void clear_client_score();

   260   static const int kClientScoreFieldNumber = 2;

   261   inline float client_score() const;

   262   inline void set_client_score(float value);

   264   // optional bool is_phishing = 4;

   265   inline bool has_is_phishing() const;

   266   inline void clear_is_phishing();

   267   static const int kIsPhishingFieldNumber = 4;

   268   inline bool is_phishing() const;

   269   inline void set_is_phishing(bool value);

   271   // repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5;

   272   inline int feature_map_size() const;

   273   inline void clear_feature_map();

   274   static const int kFeatureMapFieldNumber = 5;

   275   inline const ::safe_browsing::ClientPhishingRequest_Feature& feature_map(int index) const;

   276   inline ::safe_browsing::ClientPhishingRequest_Feature* mutable_feature_map(int index);

   277   inline ::safe_browsing::ClientPhishingRequest_Feature* add_feature_map();

   278   inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >&

   279       feature_map() const;

   280   inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >*

   281       mutable_feature_map();

   283   // optional int32 model_version = 6;

   284   inline bool has_model_version() const;

   285   inline void clear_model_version();

   286   static const int kModelVersionFieldNumber = 6;

   287   inline ::google::protobuf::int32 model_version() const;

   288   inline void set_model_version(::google::protobuf::int32 value);

   290   // repeated .safe_browsing.ClientPhishingRequest.Feature non_model_feature_map = 8;

   291   inline int non_model_feature_map_size() const;

   292   inline void clear_non_model_feature_map();

   293   static const int kNonModelFeatureMapFieldNumber = 8;

   294   inline const ::safe_browsing::ClientPhishingRequest_Feature& non_model_feature_map(int index) const;

   295   inline ::safe_browsing::ClientPhishingRequest_Feature* mutable_non_model_feature_map(int index);

   296   inline ::safe_browsing::ClientPhishingRequest_Feature* add_non_model_feature_map();

   297   inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >&

   298       non_model_feature_map() const;

   299   inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >*

   300       mutable_non_model_feature_map();

   302   // optional string OBSOLETE_referrer_url = 9;

   303   inline bool has_obsolete_referrer_url() const;

   304   inline void clear_obsolete_referrer_url();

   305   static const int kOBSOLETEReferrerUrlFieldNumber = 9;

   306   inline const ::std::string& obsolete_referrer_url() const;

   307   inline void set_obsolete_referrer_url(const ::std::string& value);

   308   inline void set_obsolete_referrer_url(const char* value);

   309   inline void set_obsolete_referrer_url(const char* value, size_t size);

   310   inline ::std::string* mutable_obsolete_referrer_url();

   311   inline ::std::string* release_obsolete_referrer_url();

   313   // @@protoc_insertion_point(class_scope:safe_browsing.ClientPhishingRequest)

   314  private:

   315   inline void set_has_url();

   316   inline void clear_has_url();

   317   inline void set_has_obsolete_hash_prefix();

   318   inline void clear_has_obsolete_hash_prefix();

   319   inline void set_has_client_score();

   320   inline void clear_has_client_score();

   321   inline void set_has_is_phishing();

   322   inline void clear_has_is_phishing();

   323   inline void set_has_model_version();

   324   inline void clear_has_model_version();

   325   inline void set_has_obsolete_referrer_url();

   326   inline void clear_has_obsolete_referrer_url();

   328   ::std::string* url_;

   329   ::std::string* obsolete_hash_prefix_;

   330   float client_score_;

   331   bool is_phishing_;

   332   ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature > feature_map_;

   333   ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature > non_model_feature_map_;

   334   ::std::string* obsolete_referrer_url_;

   335   ::google::protobuf::int32 model_version_;

   337   mutable int _cached_size_;

   338   ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];

   340   friend void  protobuf_AddDesc_csd_2eproto();

   341   friend void protobuf_AssignDesc_csd_2eproto();

   342   friend void protobuf_ShutdownFile_csd_2eproto();

   344   void InitAsDefaultInstance();

   345   static ClientPhishingRequest* default_instance_;

   346 };

   347 // -------------------------------------------------------------------

   349 class ClientPhishingResponse : public ::google::protobuf::MessageLite {

   350  public:

   351   ClientPhishingResponse();

   352   virtual ~ClientPhishingResponse();

   354   ClientPhishingResponse(const ClientPhishingResponse& from);

   356   inline ClientPhishingResponse& operator=(const ClientPhishingResponse& from) {

   357     CopyFrom(from);

   358     return *this;

   359   }

   361   static const ClientPhishingResponse& default_instance();

   363   void Swap(ClientPhishingResponse* other);

   365   // implements Message ----------------------------------------------

   367   ClientPhishingResponse* New() const;

   368   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

   369   void CopyFrom(const ClientPhishingResponse& from);

   370   void MergeFrom(const ClientPhishingResponse& from);

   371   void Clear();

   372   bool IsInitialized() const;

   374   int ByteSize() const;

   375   bool MergePartialFromCodedStream(

   376       ::google::protobuf::io::CodedInputStream* input);

   377   void SerializeWithCachedSizes(

   378       ::google::protobuf::io::CodedOutputStream* output) const;

   379   int GetCachedSize() const { return _cached_size_; }

   380   private:

   381   void SharedCtor();

   382   void SharedDtor();

   383   void SetCachedSize(int size) const;

   384   public:

   386   ::std::string GetTypeName() const;

   388   // nested types ----------------------------------------------------

   390   // accessors -------------------------------------------------------

   392   // required bool phishy = 1;

   393   inline bool has_phishy() const;

   394   inline void clear_phishy();

   395   static const int kPhishyFieldNumber = 1;

   396   inline bool phishy() const;

   397   inline void set_phishy(bool value);

   399   // repeated string OBSOLETE_whitelist_expression = 2;

   400   inline int obsolete_whitelist_expression_size() const;

   401   inline void clear_obsolete_whitelist_expression();

   402   static const int kOBSOLETEWhitelistExpressionFieldNumber = 2;

   403   inline const ::std::string& obsolete_whitelist_expression(int index) const;

   404   inline ::std::string* mutable_obsolete_whitelist_expression(int index);

   405   inline void set_obsolete_whitelist_expression(int index, const ::std::string& value);

   406   inline void set_obsolete_whitelist_expression(int index, const char* value);

   407   inline void set_obsolete_whitelist_expression(int index, const char* value, size_t size);

   408   inline ::std::string* add_obsolete_whitelist_expression();

   409   inline void add_obsolete_whitelist_expression(const ::std::string& value);

   410   inline void add_obsolete_whitelist_expression(const char* value);

   411   inline void add_obsolete_whitelist_expression(const char* value, size_t size);

   412   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& obsolete_whitelist_expression() const;

   413   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_obsolete_whitelist_expression();

   415   // @@protoc_insertion_point(class_scope:safe_browsing.ClientPhishingResponse)

   416  private:

   417   inline void set_has_phishy();

   418   inline void clear_has_phishy();

   420   ::google::protobuf::RepeatedPtrField< ::std::string> obsolete_whitelist_expression_;

   421   bool phishy_;

   423   mutable int _cached_size_;

   424   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

   426   friend void  protobuf_AddDesc_csd_2eproto();

   427   friend void protobuf_AssignDesc_csd_2eproto();

   428   friend void protobuf_ShutdownFile_csd_2eproto();

   430   void InitAsDefaultInstance();

   431   static ClientPhishingResponse* default_instance_;

   432 };

   433 // -------------------------------------------------------------------

   435 class ClientMalwareRequest_Feature : public ::google::protobuf::MessageLite {

   436  public:

   437   ClientMalwareRequest_Feature();

   438   virtual ~ClientMalwareRequest_Feature();

   440   ClientMalwareRequest_Feature(const ClientMalwareRequest_Feature& from);

   442   inline ClientMalwareRequest_Feature& operator=(const ClientMalwareRequest_Feature& from) {

   443     CopyFrom(from);

   444     return *this;

   445   }

   447   static const ClientMalwareRequest_Feature& default_instance();

   449   void Swap(ClientMalwareRequest_Feature* other);

   451   // implements Message ----------------------------------------------

   453   ClientMalwareRequest_Feature* New() const;

   454   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

   455   void CopyFrom(const ClientMalwareRequest_Feature& from);

   456   void MergeFrom(const ClientMalwareRequest_Feature& from);

   457   void Clear();

   458   bool IsInitialized() const;

   460   int ByteSize() const;

   461   bool MergePartialFromCodedStream(

   462       ::google::protobuf::io::CodedInputStream* input);

   463   void SerializeWithCachedSizes(

   464       ::google::protobuf::io::CodedOutputStream* output) const;

   465   int GetCachedSize() const { return _cached_size_; }

   466   private:

   467   void SharedCtor();

   468   void SharedDtor();

   469   void SetCachedSize(int size) const;

   470   public:

   472   ::std::string GetTypeName() const;

   474   // nested types ----------------------------------------------------

   476   // accessors -------------------------------------------------------

   478   // required string name = 1;

   479   inline bool has_name() const;

   480   inline void clear_name();

   481   static const int kNameFieldNumber = 1;

   482   inline const ::std::string& name() const;

   483   inline void set_name(const ::std::string& value);

   484   inline void set_name(const char* value);

   485   inline void set_name(const char* value, size_t size);

   486   inline ::std::string* mutable_name();

   487   inline ::std::string* release_name();

   489   // required double value = 2;

   490   inline bool has_value() const;

   491   inline void clear_value();

   492   static const int kValueFieldNumber = 2;

   493   inline double value() const;

   494   inline void set_value(double value);

   496   // repeated string metainfo = 3;

   497   inline int metainfo_size() const;

   498   inline void clear_metainfo();

   499   static const int kMetainfoFieldNumber = 3;

   500   inline const ::std::string& metainfo(int index) const;

   501   inline ::std::string* mutable_metainfo(int index);

   502   inline void set_metainfo(int index, const ::std::string& value);

   503   inline void set_metainfo(int index, const char* value);

   504   inline void set_metainfo(int index, const char* value, size_t size);

   505   inline ::std::string* add_metainfo();

   506   inline void add_metainfo(const ::std::string& value);

   507   inline void add_metainfo(const char* value);

   508   inline void add_metainfo(const char* value, size_t size);

   509   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& metainfo() const;

   510   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_metainfo();

   512   // @@protoc_insertion_point(class_scope:safe_browsing.ClientMalwareRequest.Feature)

   513  private:

   514   inline void set_has_name();

   515   inline void clear_has_name();

   516   inline void set_has_value();

   517   inline void clear_has_value();

   519   ::std::string* name_;

   520   double value_;

   521   ::google::protobuf::RepeatedPtrField< ::std::string> metainfo_;

   523   mutable int _cached_size_;

   524   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

   526   friend void  protobuf_AddDesc_csd_2eproto();

   527   friend void protobuf_AssignDesc_csd_2eproto();

   528   friend void protobuf_ShutdownFile_csd_2eproto();

   530   void InitAsDefaultInstance();

   531   static ClientMalwareRequest_Feature* default_instance_;

   532 };

   533 // -------------------------------------------------------------------

   535 class ClientMalwareRequest : public ::google::protobuf::MessageLite {

   536  public:

   537   ClientMalwareRequest();

   538   virtual ~ClientMalwareRequest();

   540   ClientMalwareRequest(const ClientMalwareRequest& from);

   542   inline ClientMalwareRequest& operator=(const ClientMalwareRequest& from) {

   543     CopyFrom(from);

   544     return *this;

   545   }

   547   static const ClientMalwareRequest& default_instance();

   549   void Swap(ClientMalwareRequest* other);

   551   // implements Message ----------------------------------------------

   553   ClientMalwareRequest* New() const;

   554   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

   555   void CopyFrom(const ClientMalwareRequest& from);

   556   void MergeFrom(const ClientMalwareRequest& from);

   557   void Clear();

   558   bool IsInitialized() const;

   560   int ByteSize() const;

   561   bool MergePartialFromCodedStream(

   562       ::google::protobuf::io::CodedInputStream* input);

   563   void SerializeWithCachedSizes(

   564       ::google::protobuf::io::CodedOutputStream* output) const;

   565   int GetCachedSize() const { return _cached_size_; }

   566   private:

   567   void SharedCtor();

   568   void SharedDtor();

   569   void SetCachedSize(int size) const;

   570   public:

   572   ::std::string GetTypeName() const;

   574   // nested types ----------------------------------------------------

   576   typedef ClientMalwareRequest_Feature Feature;

   578   // accessors -------------------------------------------------------

   580   // required string url = 1;

   581   inline bool has_url() const;

   582   inline void clear_url();

   583   static const int kUrlFieldNumber = 1;

   584   inline const ::std::string& url() const;

   585   inline void set_url(const ::std::string& value);

   586   inline void set_url(const char* value);

   587   inline void set_url(const char* value, size_t size);

   588   inline ::std::string* mutable_url();

   589   inline ::std::string* release_url();

   591   // repeated .safe_browsing.ClientMalwareRequest.Feature feature_map = 2;

   592   inline int feature_map_size() const;

   593   inline void clear_feature_map();

   594   static const int kFeatureMapFieldNumber = 2;

   595   inline const ::safe_browsing::ClientMalwareRequest_Feature& feature_map(int index) const;

   596   inline ::safe_browsing::ClientMalwareRequest_Feature* mutable_feature_map(int index);

   597   inline ::safe_browsing::ClientMalwareRequest_Feature* add_feature_map();

   598   inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_Feature >&

   599       feature_map() const;

   600   inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_Feature >*

   601       mutable_feature_map();

   603   // optional string referrer_url = 4;

   604   inline bool has_referrer_url() const;

   605   inline void clear_referrer_url();

   606   static const int kReferrerUrlFieldNumber = 4;

   607   inline const ::std::string& referrer_url() const;

   608   inline void set_referrer_url(const ::std::string& value);

   609   inline void set_referrer_url(const char* value);

   610   inline void set_referrer_url(const char* value, size_t size);

   611   inline ::std::string* mutable_referrer_url();

   612   inline ::std::string* release_referrer_url();

   614   // @@protoc_insertion_point(class_scope:safe_browsing.ClientMalwareRequest)

   615  private:

   616   inline void set_has_url();

   617   inline void clear_has_url();

   618   inline void set_has_referrer_url();

   619   inline void clear_has_referrer_url();

   621   ::std::string* url_;

   622   ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_Feature > feature_map_;

   623   ::std::string* referrer_url_;

   625   mutable int _cached_size_;

   626   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

   628   friend void  protobuf_AddDesc_csd_2eproto();

   629   friend void protobuf_AssignDesc_csd_2eproto();

   630   friend void protobuf_ShutdownFile_csd_2eproto();

   632   void InitAsDefaultInstance();

   633   static ClientMalwareRequest* default_instance_;

   634 };

   635 // -------------------------------------------------------------------

   637 class ClientMalwareResponse : public ::google::protobuf::MessageLite {

   638  public:

   639   ClientMalwareResponse();

   640   virtual ~ClientMalwareResponse();

   642   ClientMalwareResponse(const ClientMalwareResponse& from);

   644   inline ClientMalwareResponse& operator=(const ClientMalwareResponse& from) {

   645     CopyFrom(from);

   646     return *this;

   647   }

   649   static const ClientMalwareResponse& default_instance();

   651   void Swap(ClientMalwareResponse* other);

   653   // implements Message ----------------------------------------------

   655   ClientMalwareResponse* New() const;

   656   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

   657   void CopyFrom(const ClientMalwareResponse& from);

   658   void MergeFrom(const ClientMalwareResponse& from);

   659   void Clear();

   660   bool IsInitialized() const;

   662   int ByteSize() const;

   663   bool MergePartialFromCodedStream(

   664       ::google::protobuf::io::CodedInputStream* input);

   665   void SerializeWithCachedSizes(

   666       ::google::protobuf::io::CodedOutputStream* output) const;

   667   int GetCachedSize() const { return _cached_size_; }

   668   private:

   669   void SharedCtor();

   670   void SharedDtor();

   671   void SetCachedSize(int size) const;

   672   public:

   674   ::std::string GetTypeName() const;

   676   // nested types ----------------------------------------------------

   678   // accessors -------------------------------------------------------

   680   // required bool blacklist = 1;

   681   inline bool has_blacklist() const;

   682   inline void clear_blacklist();

   683   static const int kBlacklistFieldNumber = 1;

   684   inline bool blacklist() const;

   685   inline void set_blacklist(bool value);

   687   // optional string bad_ip = 2;

   688   inline bool has_bad_ip() const;

   689   inline void clear_bad_ip();

   690   static const int kBadIpFieldNumber = 2;

   691   inline const ::std::string& bad_ip() const;

   692   inline void set_bad_ip(const ::std::string& value);

   693   inline void set_bad_ip(const char* value);

   694   inline void set_bad_ip(const char* value, size_t size);

   695   inline ::std::string* mutable_bad_ip();

   696   inline ::std::string* release_bad_ip();

   698   // @@protoc_insertion_point(class_scope:safe_browsing.ClientMalwareResponse)

   699  private:

   700   inline void set_has_blacklist();

   701   inline void clear_has_blacklist();

   702   inline void set_has_bad_ip();

   703   inline void clear_has_bad_ip();

   705   ::std::string* bad_ip_;

   706   bool blacklist_;

   708   mutable int _cached_size_;

   709   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

   711   friend void  protobuf_AddDesc_csd_2eproto();

   712   friend void protobuf_AssignDesc_csd_2eproto();

   713   friend void protobuf_ShutdownFile_csd_2eproto();

   715   void InitAsDefaultInstance();

   716   static ClientMalwareResponse* default_instance_;

   717 };

   718 // -------------------------------------------------------------------

   720 class ClientDownloadRequest_Digests : public ::google::protobuf::MessageLite {

   721  public:

   722   ClientDownloadRequest_Digests();

   723   virtual ~ClientDownloadRequest_Digests();

   725   ClientDownloadRequest_Digests(const ClientDownloadRequest_Digests& from);

   727   inline ClientDownloadRequest_Digests& operator=(const ClientDownloadRequest_Digests& from) {

   728     CopyFrom(from);

   729     return *this;

   730   }

   732   static const ClientDownloadRequest_Digests& default_instance();

   734   void Swap(ClientDownloadRequest_Digests* other);

   736   // implements Message ----------------------------------------------

   738   ClientDownloadRequest_Digests* New() const;

   739   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

   740   void CopyFrom(const ClientDownloadRequest_Digests& from);

   741   void MergeFrom(const ClientDownloadRequest_Digests& from);

   742   void Clear();

   743   bool IsInitialized() const;

   745   int ByteSize() const;

   746   bool MergePartialFromCodedStream(

   747       ::google::protobuf::io::CodedInputStream* input);

   748   void SerializeWithCachedSizes(

   749       ::google::protobuf::io::CodedOutputStream* output) const;

   750   int GetCachedSize() const { return _cached_size_; }

   751   private:

   752   void SharedCtor();

   753   void SharedDtor();

   754   void SetCachedSize(int size) const;

   755   public:

   757   ::std::string GetTypeName() const;

   759   // nested types ----------------------------------------------------

   761   // accessors -------------------------------------------------------

   763   // optional bytes sha256 = 1;

   764   inline bool has_sha256() const;

   765   inline void clear_sha256();

   766   static const int kSha256FieldNumber = 1;

   767   inline const ::std::string& sha256() const;

   768   inline void set_sha256(const ::std::string& value);

   769   inline void set_sha256(const char* value);

   770   inline void set_sha256(const void* value, size_t size);

   771   inline ::std::string* mutable_sha256();

   772   inline ::std::string* release_sha256();

   774   // optional bytes sha1 = 2;

   775   inline bool has_sha1() const;

   776   inline void clear_sha1();

   777   static const int kSha1FieldNumber = 2;

   778   inline const ::std::string& sha1() const;

   779   inline void set_sha1(const ::std::string& value);

   780   inline void set_sha1(const char* value);

   781   inline void set_sha1(const void* value, size_t size);

   782   inline ::std::string* mutable_sha1();

   783   inline ::std::string* release_sha1();

   785   // optional bytes md5 = 3;

   786   inline bool has_md5() const;

   787   inline void clear_md5();

   788   static const int kMd5FieldNumber = 3;

   789   inline const ::std::string& md5() const;

   790   inline void set_md5(const ::std::string& value);

   791   inline void set_md5(const char* value);

   792   inline void set_md5(const void* value, size_t size);

   793   inline ::std::string* mutable_md5();

   794   inline ::std::string* release_md5();

   796   // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.Digests)

   797  private:

   798   inline void set_has_sha256();

   799   inline void clear_has_sha256();

   800   inline void set_has_sha1();

   801   inline void clear_has_sha1();

   802   inline void set_has_md5();

   803   inline void clear_has_md5();

   805   ::std::string* sha256_;

   806   ::std::string* sha1_;

   807   ::std::string* md5_;

   809   mutable int _cached_size_;

   810   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

   812   friend void  protobuf_AddDesc_csd_2eproto();

   813   friend void protobuf_AssignDesc_csd_2eproto();

   814   friend void protobuf_ShutdownFile_csd_2eproto();

   816   void InitAsDefaultInstance();

   817   static ClientDownloadRequest_Digests* default_instance_;

   818 };

   819 // -------------------------------------------------------------------

   821 class ClientDownloadRequest_Resource : public ::google::protobuf::MessageLite {

   822  public:

   823   ClientDownloadRequest_Resource();

   824   virtual ~ClientDownloadRequest_Resource();

   826   ClientDownloadRequest_Resource(const ClientDownloadRequest_Resource& from);

   828   inline ClientDownloadRequest_Resource& operator=(const ClientDownloadRequest_Resource& from) {

   829     CopyFrom(from);

   830     return *this;

   831   }

   833   static const ClientDownloadRequest_Resource& default_instance();

   835   void Swap(ClientDownloadRequest_Resource* other);

   837   // implements Message ----------------------------------------------

   839   ClientDownloadRequest_Resource* New() const;

   840   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

   841   void CopyFrom(const ClientDownloadRequest_Resource& from);

   842   void MergeFrom(const ClientDownloadRequest_Resource& from);

   843   void Clear();

   844   bool IsInitialized() const;

   846   int ByteSize() const;

   847   bool MergePartialFromCodedStream(

   848       ::google::protobuf::io::CodedInputStream* input);

   849   void SerializeWithCachedSizes(

   850       ::google::protobuf::io::CodedOutputStream* output) const;

   851   int GetCachedSize() const { return _cached_size_; }

   852   private:

   853   void SharedCtor();

   854   void SharedDtor();

   855   void SetCachedSize(int size) const;

   856   public:

   858   ::std::string GetTypeName() const;

   860   // nested types ----------------------------------------------------

   862   // accessors -------------------------------------------------------

   864   // required string url = 1;

   865   inline bool has_url() const;

   866   inline void clear_url();

   867   static const int kUrlFieldNumber = 1;

   868   inline const ::std::string& url() const;

   869   inline void set_url(const ::std::string& value);

   870   inline void set_url(const char* value);

   871   inline void set_url(const char* value, size_t size);

   872   inline ::std::string* mutable_url();

   873   inline ::std::string* release_url();

   875   // required .safe_browsing.ClientDownloadRequest.ResourceType type = 2;

   876   inline bool has_type() const;

   877   inline void clear_type();

   878   static const int kTypeFieldNumber = 2;

   879   inline ::safe_browsing::ClientDownloadRequest_ResourceType type() const;

   880   inline void set_type(::safe_browsing::ClientDownloadRequest_ResourceType value);

   882   // optional bytes remote_ip = 3;

   883   inline bool has_remote_ip() const;

   884   inline void clear_remote_ip();

   885   static const int kRemoteIpFieldNumber = 3;

   886   inline const ::std::string& remote_ip() const;

   887   inline void set_remote_ip(const ::std::string& value);

   888   inline void set_remote_ip(const char* value);

   889   inline void set_remote_ip(const void* value, size_t size);

   890   inline ::std::string* mutable_remote_ip();

   891   inline ::std::string* release_remote_ip();

   893   // optional string referrer = 4;

   894   inline bool has_referrer() const;

   895   inline void clear_referrer();

   896   static const int kReferrerFieldNumber = 4;

   897   inline const ::std::string& referrer() const;

   898   inline void set_referrer(const ::std::string& value);

   899   inline void set_referrer(const char* value);

   900   inline void set_referrer(const char* value, size_t size);

   901   inline ::std::string* mutable_referrer();

   902   inline ::std::string* release_referrer();

   904   // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.Resource)

   905  private:

   906   inline void set_has_url();

   907   inline void clear_has_url();

   908   inline void set_has_type();

   909   inline void clear_has_type();

   910   inline void set_has_remote_ip();

   911   inline void clear_has_remote_ip();

   912   inline void set_has_referrer();

   913   inline void clear_has_referrer();

   915   ::std::string* url_;

   916   ::std::string* remote_ip_;

   917   ::std::string* referrer_;

   918   int type_;

   920   mutable int _cached_size_;

   921   ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

   923   friend void  protobuf_AddDesc_csd_2eproto();

   924   friend void protobuf_AssignDesc_csd_2eproto();

   925   friend void protobuf_ShutdownFile_csd_2eproto();

   927   void InitAsDefaultInstance();

   928   static ClientDownloadRequest_Resource* default_instance_;

   929 };

   930 // -------------------------------------------------------------------

   932 class ClientDownloadRequest_CertificateChain_Element : public ::google::protobuf::MessageLite {

   933  public:

   934   ClientDownloadRequest_CertificateChain_Element();

   935   virtual ~ClientDownloadRequest_CertificateChain_Element();

   937   ClientDownloadRequest_CertificateChain_Element(const ClientDownloadRequest_CertificateChain_Element& from);

   939   inline ClientDownloadRequest_CertificateChain_Element& operator=(const ClientDownloadRequest_CertificateChain_Element& from) {

   940     CopyFrom(from);

   941     return *this;

   942   }

   944   static const ClientDownloadRequest_CertificateChain_Element& default_instance();

   946   void Swap(ClientDownloadRequest_CertificateChain_Element* other);

   948   // implements Message ----------------------------------------------

   950   ClientDownloadRequest_CertificateChain_Element* New() const;

   951   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

   952   void CopyFrom(const ClientDownloadRequest_CertificateChain_Element& from);

   953   void MergeFrom(const ClientDownloadRequest_CertificateChain_Element& from);

   954   void Clear();

   955   bool IsInitialized() const;

   957   int ByteSize() const;

   958   bool MergePartialFromCodedStream(

   959       ::google::protobuf::io::CodedInputStream* input);

   960   void SerializeWithCachedSizes(

   961       ::google::protobuf::io::CodedOutputStream* output) const;

   962   int GetCachedSize() const { return _cached_size_; }

   963   private:

   964   void SharedCtor();

   965   void SharedDtor();

   966   void SetCachedSize(int size) const;

   967   public:

   969   ::std::string GetTypeName() const;

   971   // nested types ----------------------------------------------------

   973   // accessors -------------------------------------------------------

   975   // optional bytes certificate = 1;

   976   inline bool has_certificate() const;

   977   inline void clear_certificate();

   978   static const int kCertificateFieldNumber = 1;

   979   inline const ::std::string& certificate() const;

   980   inline void set_certificate(const ::std::string& value);

   981   inline void set_certificate(const char* value);

   982   inline void set_certificate(const void* value, size_t size);

   983   inline ::std::string* mutable_certificate();

   984   inline ::std::string* release_certificate();

   986   // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.CertificateChain.Element)

   987  private:

   988   inline void set_has_certificate();

   989   inline void clear_has_certificate();

   991   ::std::string* certificate_;

   993   mutable int _cached_size_;

   994   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

   996   friend void  protobuf_AddDesc_csd_2eproto();

   997   friend void protobuf_AssignDesc_csd_2eproto();

   998   friend void protobuf_ShutdownFile_csd_2eproto();

  1000   void InitAsDefaultInstance();

  1001   static ClientDownloadRequest_CertificateChain_Element* default_instance_;

  1002 };

  1003 // -------------------------------------------------------------------

  1005 class ClientDownloadRequest_CertificateChain : public ::google::protobuf::MessageLite {

  1006  public:

  1007   ClientDownloadRequest_CertificateChain();

  1008   virtual ~ClientDownloadRequest_CertificateChain();

  1010   ClientDownloadRequest_CertificateChain(const ClientDownloadRequest_CertificateChain& from);

  1012   inline ClientDownloadRequest_CertificateChain& operator=(const ClientDownloadRequest_CertificateChain& from) {

  1013     CopyFrom(from);

  1014     return *this;

  1015   }

  1017   static const ClientDownloadRequest_CertificateChain& default_instance();

  1019   void Swap(ClientDownloadRequest_CertificateChain* other);

  1021   // implements Message ----------------------------------------------

  1023   ClientDownloadRequest_CertificateChain* New() const;

  1024   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

  1025   void CopyFrom(const ClientDownloadRequest_CertificateChain& from);

  1026   void MergeFrom(const ClientDownloadRequest_CertificateChain& from);

  1027   void Clear();

  1028   bool IsInitialized() const;

  1030   int ByteSize() const;

  1031   bool MergePartialFromCodedStream(

  1032       ::google::protobuf::io::CodedInputStream* input);

  1033   void SerializeWithCachedSizes(

  1034       ::google::protobuf::io::CodedOutputStream* output) const;

  1035   int GetCachedSize() const { return _cached_size_; }

  1036   private:

  1037   void SharedCtor();

  1038   void SharedDtor();

  1039   void SetCachedSize(int size) const;

  1040   public:

  1042   ::std::string GetTypeName() const;

  1044   // nested types ----------------------------------------------------

  1046   typedef ClientDownloadRequest_CertificateChain_Element Element;

  1048   // accessors -------------------------------------------------------

  1050   // repeated .safe_browsing.ClientDownloadRequest.CertificateChain.Element element = 1;

  1051   inline int element_size() const;

  1052   inline void clear_element();

  1053   static const int kElementFieldNumber = 1;

  1054   inline const ::safe_browsing::ClientDownloadRequest_CertificateChain_Element& element(int index) const;

  1055   inline ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* mutable_element(int index);

  1056   inline ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* add_element();

  1057   inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >&

  1058       element() const;

  1059   inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >*

  1060       mutable_element();

  1062   // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.CertificateChain)

  1063  private:

  1065   ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element > element_;

  1067   mutable int _cached_size_;

  1068   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  1070   friend void  protobuf_AddDesc_csd_2eproto();

  1071   friend void protobuf_AssignDesc_csd_2eproto();

  1072   friend void protobuf_ShutdownFile_csd_2eproto();

  1074   void InitAsDefaultInstance();

  1075   static ClientDownloadRequest_CertificateChain* default_instance_;

  1076 };

  1077 // -------------------------------------------------------------------

  1079 class ClientDownloadRequest_SignatureInfo : public ::google::protobuf::MessageLite {

  1080  public:

  1081   ClientDownloadRequest_SignatureInfo();

  1082   virtual ~ClientDownloadRequest_SignatureInfo();

  1084   ClientDownloadRequest_SignatureInfo(const ClientDownloadRequest_SignatureInfo& from);

  1086   inline ClientDownloadRequest_SignatureInfo& operator=(const ClientDownloadRequest_SignatureInfo& from) {

  1087     CopyFrom(from);

  1088     return *this;

  1089   }

  1091   static const ClientDownloadRequest_SignatureInfo& default_instance();

  1093   void Swap(ClientDownloadRequest_SignatureInfo* other);

  1095   // implements Message ----------------------------------------------

  1097   ClientDownloadRequest_SignatureInfo* New() const;

  1098   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

  1099   void CopyFrom(const ClientDownloadRequest_SignatureInfo& from);

  1100   void MergeFrom(const ClientDownloadRequest_SignatureInfo& from);

  1101   void Clear();

  1102   bool IsInitialized() const;

  1104   int ByteSize() const;

  1105   bool MergePartialFromCodedStream(

  1106       ::google::protobuf::io::CodedInputStream* input);

  1107   void SerializeWithCachedSizes(

  1108       ::google::protobuf::io::CodedOutputStream* output) const;

  1109   int GetCachedSize() const { return _cached_size_; }

  1110   private:

  1111   void SharedCtor();

  1112   void SharedDtor();

  1113   void SetCachedSize(int size) const;

  1114   public:

  1116   ::std::string GetTypeName() const;

  1118   // nested types ----------------------------------------------------

  1120   // accessors -------------------------------------------------------

  1122   // repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1;

  1123   inline int certificate_chain_size() const;

  1124   inline void clear_certificate_chain();

  1125   static const int kCertificateChainFieldNumber = 1;

  1126   inline const ::safe_browsing::ClientDownloadRequest_CertificateChain& certificate_chain(int index) const;

  1127   inline ::safe_browsing::ClientDownloadRequest_CertificateChain* mutable_certificate_chain(int index);

  1128   inline ::safe_browsing::ClientDownloadRequest_CertificateChain* add_certificate_chain();

  1129   inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain >&

  1130       certificate_chain() const;

  1131   inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain >*

  1132       mutable_certificate_chain();

  1134   // optional bool trusted = 2;

  1135   inline bool has_trusted() const;

  1136   inline void clear_trusted();

  1137   static const int kTrustedFieldNumber = 2;

  1138   inline bool trusted() const;

  1139   inline void set_trusted(bool value);

  1141   // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.SignatureInfo)

  1142  private:

  1143   inline void set_has_trusted();

  1144   inline void clear_has_trusted();

  1146   ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain > certificate_chain_;

  1147   bool trusted_;

  1149   mutable int _cached_size_;

  1150   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  1152   friend void  protobuf_AddDesc_csd_2eproto();

  1153   friend void protobuf_AssignDesc_csd_2eproto();

  1154   friend void protobuf_ShutdownFile_csd_2eproto();

  1156   void InitAsDefaultInstance();

  1157   static ClientDownloadRequest_SignatureInfo* default_instance_;

  1158 };

  1159 // -------------------------------------------------------------------

  1161 class ClientDownloadRequest : public ::google::protobuf::MessageLite {

  1162  public:

  1163   ClientDownloadRequest();

  1164   virtual ~ClientDownloadRequest();

  1166   ClientDownloadRequest(const ClientDownloadRequest& from);

  1168   inline ClientDownloadRequest& operator=(const ClientDownloadRequest& from) {

  1169     CopyFrom(from);

  1170     return *this;

  1171   }

  1173   static const ClientDownloadRequest& default_instance();

  1175   void Swap(ClientDownloadRequest* other);

  1177   // implements Message ----------------------------------------------

  1179   ClientDownloadRequest* New() const;

  1180   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

  1181   void CopyFrom(const ClientDownloadRequest& from);

  1182   void MergeFrom(const ClientDownloadRequest& from);

  1183   void Clear();

  1184   bool IsInitialized() const;

  1186   int ByteSize() const;

  1187   bool MergePartialFromCodedStream(

  1188       ::google::protobuf::io::CodedInputStream* input);

  1189   void SerializeWithCachedSizes(

  1190       ::google::protobuf::io::CodedOutputStream* output) const;

  1191   int GetCachedSize() const { return _cached_size_; }

  1192   private:

  1193   void SharedCtor();

  1194   void SharedDtor();

  1195   void SetCachedSize(int size) const;

  1196   public:

  1198   ::std::string GetTypeName() const;

  1200   // nested types ----------------------------------------------------

  1202   typedef ClientDownloadRequest_Digests Digests;

  1203   typedef ClientDownloadRequest_Resource Resource;

  1204   typedef ClientDownloadRequest_CertificateChain CertificateChain;

  1205   typedef ClientDownloadRequest_SignatureInfo SignatureInfo;

  1207   typedef ClientDownloadRequest_ResourceType ResourceType;

  1208   static const ResourceType DOWNLOAD_URL = ClientDownloadRequest_ResourceType_DOWNLOAD_URL;

  1209   static const ResourceType DOWNLOAD_REDIRECT = ClientDownloadRequest_ResourceType_DOWNLOAD_REDIRECT;

  1210   static const ResourceType TAB_URL = ClientDownloadRequest_ResourceType_TAB_URL;

  1211   static const ResourceType TAB_REDIRECT = ClientDownloadRequest_ResourceType_TAB_REDIRECT;

  1212   static inline bool ResourceType_IsValid(int value) {

  1213     return ClientDownloadRequest_ResourceType_IsValid(value);

  1214   }

  1215   static const ResourceType ResourceType_MIN =

  1216     ClientDownloadRequest_ResourceType_ResourceType_MIN;

  1217   static const ResourceType ResourceType_MAX =

  1218     ClientDownloadRequest_ResourceType_ResourceType_MAX;

  1219   static const int ResourceType_ARRAYSIZE =

  1220     ClientDownloadRequest_ResourceType_ResourceType_ARRAYSIZE;

  1222   typedef ClientDownloadRequest_DownloadType DownloadType;

  1223   static const DownloadType WIN_EXECUTABLE = ClientDownloadRequest_DownloadType_WIN_EXECUTABLE;

  1224   static const DownloadType CHROME_EXTENSION = ClientDownloadRequest_DownloadType_CHROME_EXTENSION;

  1225   static const DownloadType ANDROID_APK = ClientDownloadRequest_DownloadType_ANDROID_APK;

  1226   static const DownloadType ZIPPED_EXECUTABLE = ClientDownloadRequest_DownloadType_ZIPPED_EXECUTABLE;

  1227   static inline bool DownloadType_IsValid(int value) {

  1228     return ClientDownloadRequest_DownloadType_IsValid(value);

  1229   }

  1230   static const DownloadType DownloadType_MIN =

  1231     ClientDownloadRequest_DownloadType_DownloadType_MIN;

  1232   static const DownloadType DownloadType_MAX =

  1233     ClientDownloadRequest_DownloadType_DownloadType_MAX;

  1234   static const int DownloadType_ARRAYSIZE =

  1235     ClientDownloadRequest_DownloadType_DownloadType_ARRAYSIZE;

  1237   // accessors -------------------------------------------------------

  1239   // required string url = 1;

  1240   inline bool has_url() const;

  1241   inline void clear_url();

  1242   static const int kUrlFieldNumber = 1;

  1243   inline const ::std::string& url() const;

  1244   inline void set_url(const ::std::string& value);

  1245   inline void set_url(const char* value);

  1246   inline void set_url(const char* value, size_t size);

  1247   inline ::std::string* mutable_url();

  1248   inline ::std::string* release_url();

  1250   // required .safe_browsing.ClientDownloadRequest.Digests digests = 2;

  1251   inline bool has_digests() const;

  1252   inline void clear_digests();

  1253   static const int kDigestsFieldNumber = 2;

  1254   inline const ::safe_browsing::ClientDownloadRequest_Digests& digests() const;

  1255   inline ::safe_browsing::ClientDownloadRequest_Digests* mutable_digests();

  1256   inline ::safe_browsing::ClientDownloadRequest_Digests* release_digests();

  1258   // required int64 length = 3;

  1259   inline bool has_length() const;

  1260   inline void clear_length();

  1261   static const int kLengthFieldNumber = 3;

  1262   inline ::google::protobuf::int64 length() const;

  1263   inline void set_length(::google::protobuf::int64 value);

  1265   // repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4;

  1266   inline int resources_size() const;

  1267   inline void clear_resources();

  1268   static const int kResourcesFieldNumber = 4;

  1269   inline const ::safe_browsing::ClientDownloadRequest_Resource& resources(int index) const;

  1270   inline ::safe_browsing::ClientDownloadRequest_Resource* mutable_resources(int index);

  1271   inline ::safe_browsing::ClientDownloadRequest_Resource* add_resources();

  1272   inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource >&

  1273       resources() const;

  1274   inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource >*

  1275       mutable_resources();

  1277   // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;

  1278   inline bool has_signature() const;

  1279   inline void clear_signature();

  1280   static const int kSignatureFieldNumber = 5;

  1281   inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& signature() const;

  1282   inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* mutable_signature();

  1283   inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* release_signature();

  1285   // optional bool user_initiated = 6;

  1286   inline bool has_user_initiated() const;

  1287   inline void clear_user_initiated();

  1288   static const int kUserInitiatedFieldNumber = 6;

  1289   inline bool user_initiated() const;

  1290   inline void set_user_initiated(bool value);

  1292   // optional string file_basename = 9;

  1293   inline bool has_file_basename() const;

  1294   inline void clear_file_basename();

  1295   static const int kFileBasenameFieldNumber = 9;

  1296   inline const ::std::string& file_basename() const;

  1297   inline void set_file_basename(const ::std::string& value);

  1298   inline void set_file_basename(const char* value);

  1299   inline void set_file_basename(const char* value, size_t size);

  1300   inline ::std::string* mutable_file_basename();

  1301   inline ::std::string* release_file_basename();

  1303   // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 10 [default = WIN_EXECUTABLE];

  1304   inline bool has_download_type() const;

  1305   inline void clear_download_type();

  1306   static const int kDownloadTypeFieldNumber = 10;

  1307   inline ::safe_browsing::ClientDownloadRequest_DownloadType download_type() const;

  1308   inline void set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value);

  1310   // optional string locale = 11;

  1311   inline bool has_locale() const;

  1312   inline void clear_locale();

  1313   static const int kLocaleFieldNumber = 11;

  1314   inline const ::std::string& locale() const;

  1315   inline void set_locale(const ::std::string& value);

  1316   inline void set_locale(const char* value);

  1317   inline void set_locale(const char* value, size_t size);

  1318   inline ::std::string* mutable_locale();

  1319   inline ::std::string* release_locale();

  1321   // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest)

  1322  private:

  1323   inline void set_has_url();

  1324   inline void clear_has_url();

  1325   inline void set_has_digests();

  1326   inline void clear_has_digests();

  1327   inline void set_has_length();

  1328   inline void clear_has_length();

  1329   inline void set_has_signature();

  1330   inline void clear_has_signature();

  1331   inline void set_has_user_initiated();

  1332   inline void clear_has_user_initiated();

  1333   inline void set_has_file_basename();

  1334   inline void clear_has_file_basename();

  1335   inline void set_has_download_type();

  1336   inline void clear_has_download_type();

  1337   inline void set_has_locale();

  1338   inline void clear_has_locale();

  1340   ::std::string* url_;

  1341   ::safe_browsing::ClientDownloadRequest_Digests* digests_;

  1342   ::google::protobuf::int64 length_;

  1343   ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource > resources_;

  1344   ::safe_browsing::ClientDownloadRequest_SignatureInfo* signature_;

  1345   ::std::string* file_basename_;

  1346   bool user_initiated_;

  1347   int download_type_;

  1348   ::std::string* locale_;

  1350   mutable int _cached_size_;

  1351   ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];

  1353   friend void  protobuf_AddDesc_csd_2eproto();

  1354   friend void protobuf_AssignDesc_csd_2eproto();

  1355   friend void protobuf_ShutdownFile_csd_2eproto();

  1357   void InitAsDefaultInstance();

  1358   static ClientDownloadRequest* default_instance_;

  1359 };

  1360 // -------------------------------------------------------------------

  1362 class ClientDownloadResponse_MoreInfo : public ::google::protobuf::MessageLite {

  1363  public:

  1364   ClientDownloadResponse_MoreInfo();

  1365   virtual ~ClientDownloadResponse_MoreInfo();

  1367   ClientDownloadResponse_MoreInfo(const ClientDownloadResponse_MoreInfo& from);

  1369   inline ClientDownloadResponse_MoreInfo& operator=(const ClientDownloadResponse_MoreInfo& from) {

  1370     CopyFrom(from);

  1371     return *this;

  1372   }

  1374   static const ClientDownloadResponse_MoreInfo& default_instance();

  1376   void Swap(ClientDownloadResponse_MoreInfo* other);

  1378   // implements Message ----------------------------------------------

  1380   ClientDownloadResponse_MoreInfo* New() const;

  1381   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

  1382   void CopyFrom(const ClientDownloadResponse_MoreInfo& from);

  1383   void MergeFrom(const ClientDownloadResponse_MoreInfo& from);

  1384   void Clear();

  1385   bool IsInitialized() const;

  1387   int ByteSize() const;

  1388   bool MergePartialFromCodedStream(

  1389       ::google::protobuf::io::CodedInputStream* input);

  1390   void SerializeWithCachedSizes(

  1391       ::google::protobuf::io::CodedOutputStream* output) const;

  1392   int GetCachedSize() const { return _cached_size_; }

  1393   private:

  1394   void SharedCtor();

  1395   void SharedDtor();

  1396   void SetCachedSize(int size) const;

  1397   public:

  1399   ::std::string GetTypeName() const;

  1401   // nested types ----------------------------------------------------

  1403   // accessors -------------------------------------------------------

  1405   // optional string description = 1;

  1406   inline bool has_description() const;

  1407   inline void clear_description();

  1408   static const int kDescriptionFieldNumber = 1;

  1409   inline const ::std::string& description() const;

  1410   inline void set_description(const ::std::string& value);

  1411   inline void set_description(const char* value);

  1412   inline void set_description(const char* value, size_t size);

  1413   inline ::std::string* mutable_description();

  1414   inline ::std::string* release_description();

  1416   // optional string url = 2;

  1417   inline bool has_url() const;

  1418   inline void clear_url();

  1419   static const int kUrlFieldNumber = 2;

  1420   inline const ::std::string& url() const;

  1421   inline void set_url(const ::std::string& value);

  1422   inline void set_url(const char* value);

  1423   inline void set_url(const char* value, size_t size);

  1424   inline ::std::string* mutable_url();

  1425   inline ::std::string* release_url();

  1427   // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadResponse.MoreInfo)

  1428  private:

  1429   inline void set_has_description();

  1430   inline void clear_has_description();

  1431   inline void set_has_url();

  1432   inline void clear_has_url();

  1434   ::std::string* description_;

  1435   ::std::string* url_;

  1437   mutable int _cached_size_;

  1438   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  1440   friend void  protobuf_AddDesc_csd_2eproto();

  1441   friend void protobuf_AssignDesc_csd_2eproto();

  1442   friend void protobuf_ShutdownFile_csd_2eproto();

  1444   void InitAsDefaultInstance();

  1445   static ClientDownloadResponse_MoreInfo* default_instance_;

  1446 };

  1447 // -------------------------------------------------------------------

  1449 class ClientDownloadResponse : public ::google::protobuf::MessageLite {

  1450  public:

  1451   ClientDownloadResponse();

  1452   virtual ~ClientDownloadResponse();

  1454   ClientDownloadResponse(const ClientDownloadResponse& from);

  1456   inline ClientDownloadResponse& operator=(const ClientDownloadResponse& from) {

  1457     CopyFrom(from);

  1458     return *this;

  1459   }

  1461   static const ClientDownloadResponse& default_instance();

  1463   void Swap(ClientDownloadResponse* other);

  1465   // implements Message ----------------------------------------------

  1467   ClientDownloadResponse* New() const;

  1468   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

  1469   void CopyFrom(const ClientDownloadResponse& from);

  1470   void MergeFrom(const ClientDownloadResponse& from);

  1471   void Clear();

  1472   bool IsInitialized() const;

  1474   int ByteSize() const;

  1475   bool MergePartialFromCodedStream(

  1476       ::google::protobuf::io::CodedInputStream* input);

  1477   void SerializeWithCachedSizes(

  1478       ::google::protobuf::io::CodedOutputStream* output) const;

  1479   int GetCachedSize() const { return _cached_size_; }

  1480   private:

  1481   void SharedCtor();

  1482   void SharedDtor();

  1483   void SetCachedSize(int size) const;

  1484   public:

  1486   ::std::string GetTypeName() const;

  1488   // nested types ----------------------------------------------------

  1490   typedef ClientDownloadResponse_MoreInfo MoreInfo;

  1492   typedef ClientDownloadResponse_Verdict Verdict;

  1493   static const Verdict SAFE = ClientDownloadResponse_Verdict_SAFE;

  1494   static const Verdict DANGEROUS = ClientDownloadResponse_Verdict_DANGEROUS;

  1495   static const Verdict UNCOMMON = ClientDownloadResponse_Verdict_UNCOMMON;

  1496   static const Verdict POTENTIALLY_UNWANTED = ClientDownloadResponse_Verdict_POTENTIALLY_UNWANTED;

  1497   static const Verdict DANGEROUS_HOST = ClientDownloadResponse_Verdict_DANGEROUS_HOST;

  1498   static inline bool Verdict_IsValid(int value) {

  1499     return ClientDownloadResponse_Verdict_IsValid(value);

  1500   }

  1501   static const Verdict Verdict_MIN =

  1502     ClientDownloadResponse_Verdict_Verdict_MIN;

  1503   static const Verdict Verdict_MAX =

  1504     ClientDownloadResponse_Verdict_Verdict_MAX;

  1505   static const int Verdict_ARRAYSIZE =

  1506     ClientDownloadResponse_Verdict_Verdict_ARRAYSIZE;

  1508   // accessors -------------------------------------------------------

  1510   // required .safe_browsing.ClientDownloadResponse.Verdict verdict = 1;

  1511   inline bool has_verdict() const;

  1512   inline void clear_verdict();

  1513   static const int kVerdictFieldNumber = 1;

  1514   inline ::safe_browsing::ClientDownloadResponse_Verdict verdict() const;

  1515   inline void set_verdict(::safe_browsing::ClientDownloadResponse_Verdict value);

  1517   // optional .safe_browsing.ClientDownloadResponse.MoreInfo more_info = 2;

  1518   inline bool has_more_info() const;

  1519   inline void clear_more_info();

  1520   static const int kMoreInfoFieldNumber = 2;

  1521   inline const ::safe_browsing::ClientDownloadResponse_MoreInfo& more_info() const;

  1522   inline ::safe_browsing::ClientDownloadResponse_MoreInfo* mutable_more_info();

  1523   inline ::safe_browsing::ClientDownloadResponse_MoreInfo* release_more_info();

  1525   // optional bytes token = 3;

  1526   inline bool has_token() const;

  1527   inline void clear_token();

  1528   static const int kTokenFieldNumber = 3;

  1529   inline const ::std::string& token() const;

  1530   inline void set_token(const ::std::string& value);

  1531   inline void set_token(const char* value);

  1532   inline void set_token(const void* value, size_t size);

  1533   inline ::std::string* mutable_token();

  1534   inline ::std::string* release_token();

  1536   // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadResponse)

  1537  private:

  1538   inline void set_has_verdict();

  1539   inline void clear_has_verdict();

  1540   inline void set_has_more_info();

  1541   inline void clear_has_more_info();

  1542   inline void set_has_token();

  1543   inline void clear_has_token();

  1545   ::safe_browsing::ClientDownloadResponse_MoreInfo* more_info_;

  1546   ::std::string* token_;

  1547   int verdict_;

  1549   mutable int _cached_size_;

  1550   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  1552   friend void  protobuf_AddDesc_csd_2eproto();

  1553   friend void protobuf_AssignDesc_csd_2eproto();

  1554   friend void protobuf_ShutdownFile_csd_2eproto();

  1556   void InitAsDefaultInstance();

  1557   static ClientDownloadResponse* default_instance_;

  1558 };

  1559 // -------------------------------------------------------------------

  1561 class ClientDownloadReport_UserInformation : public ::google::protobuf::MessageLite {

  1562  public:

  1563   ClientDownloadReport_UserInformation();

  1564   virtual ~ClientDownloadReport_UserInformation();

  1566   ClientDownloadReport_UserInformation(const ClientDownloadReport_UserInformation& from);

  1568   inline ClientDownloadReport_UserInformation& operator=(const ClientDownloadReport_UserInformation& from) {

  1569     CopyFrom(from);

  1570     return *this;

  1571   }

  1573   static const ClientDownloadReport_UserInformation& default_instance();

  1575   void Swap(ClientDownloadReport_UserInformation* other);

  1577   // implements Message ----------------------------------------------

  1579   ClientDownloadReport_UserInformation* New() const;

  1580   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

  1581   void CopyFrom(const ClientDownloadReport_UserInformation& from);

  1582   void MergeFrom(const ClientDownloadReport_UserInformation& from);

  1583   void Clear();

  1584   bool IsInitialized() const;

  1586   int ByteSize() const;

  1587   bool MergePartialFromCodedStream(

  1588       ::google::protobuf::io::CodedInputStream* input);

  1589   void SerializeWithCachedSizes(

  1590       ::google::protobuf::io::CodedOutputStream* output) const;

  1591   int GetCachedSize() const { return _cached_size_; }

  1592   private:

  1593   void SharedCtor();

  1594   void SharedDtor();

  1595   void SetCachedSize(int size) const;

  1596   public:

  1598   ::std::string GetTypeName() const;

  1600   // nested types ----------------------------------------------------

  1602   // accessors -------------------------------------------------------

  1604   // optional string email = 1;

  1605   inline bool has_email() const;

  1606   inline void clear_email();

  1607   static const int kEmailFieldNumber = 1;

  1608   inline const ::std::string& email() const;

  1609   inline void set_email(const ::std::string& value);

  1610   inline void set_email(const char* value);

  1611   inline void set_email(const char* value, size_t size);

  1612   inline ::std::string* mutable_email();

  1613   inline ::std::string* release_email();

  1615   // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadReport.UserInformation)

  1616  private:

  1617   inline void set_has_email();

  1618   inline void clear_has_email();

  1620   ::std::string* email_;

  1622   mutable int _cached_size_;

  1623   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  1625   friend void  protobuf_AddDesc_csd_2eproto();

  1626   friend void protobuf_AssignDesc_csd_2eproto();

  1627   friend void protobuf_ShutdownFile_csd_2eproto();

  1629   void InitAsDefaultInstance();

  1630   static ClientDownloadReport_UserInformation* default_instance_;

  1631 };

  1632 // -------------------------------------------------------------------

  1634 class ClientDownloadReport : public ::google::protobuf::MessageLite {

  1635  public:

  1636   ClientDownloadReport();

  1637   virtual ~ClientDownloadReport();

  1639   ClientDownloadReport(const ClientDownloadReport& from);

  1641   inline ClientDownloadReport& operator=(const ClientDownloadReport& from) {

  1642     CopyFrom(from);

  1643     return *this;

  1644   }

  1646   static const ClientDownloadReport& default_instance();

  1648   void Swap(ClientDownloadReport* other);

  1650   // implements Message ----------------------------------------------

  1652   ClientDownloadReport* New() const;

  1653   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

  1654   void CopyFrom(const ClientDownloadReport& from);

  1655   void MergeFrom(const ClientDownloadReport& from);

  1656   void Clear();

  1657   bool IsInitialized() const;

  1659   int ByteSize() const;

  1660   bool MergePartialFromCodedStream(

  1661       ::google::protobuf::io::CodedInputStream* input);

  1662   void SerializeWithCachedSizes(

  1663       ::google::protobuf::io::CodedOutputStream* output) const;

  1664   int GetCachedSize() const { return _cached_size_; }

  1665   private:

  1666   void SharedCtor();

  1667   void SharedDtor();

  1668   void SetCachedSize(int size) const;

  1669   public:

  1671   ::std::string GetTypeName() const;

  1673   // nested types ----------------------------------------------------

  1675   typedef ClientDownloadReport_UserInformation UserInformation;

  1677   typedef ClientDownloadReport_Reason Reason;

  1678   static const Reason SHARE = ClientDownloadReport_Reason_SHARE;

  1679   static const Reason FALSE_POSITIVE = ClientDownloadReport_Reason_FALSE_POSITIVE;

  1680   static const Reason APPEAL = ClientDownloadReport_Reason_APPEAL;

  1681   static inline bool Reason_IsValid(int value) {

  1682     return ClientDownloadReport_Reason_IsValid(value);

  1683   }

  1684   static const Reason Reason_MIN =

  1685     ClientDownloadReport_Reason_Reason_MIN;

  1686   static const Reason Reason_MAX =

  1687     ClientDownloadReport_Reason_Reason_MAX;

  1688   static const int Reason_ARRAYSIZE =

  1689     ClientDownloadReport_Reason_Reason_ARRAYSIZE;

  1691   // accessors -------------------------------------------------------

  1693   // optional .safe_browsing.ClientDownloadReport.Reason reason = 1;

  1694   inline bool has_reason() const;

  1695   inline void clear_reason();

  1696   static const int kReasonFieldNumber = 1;

  1697   inline ::safe_browsing::ClientDownloadReport_Reason reason() const;

  1698   inline void set_reason(::safe_browsing::ClientDownloadReport_Reason value);

  1700   // optional .safe_browsing.ClientDownloadRequest download_request = 2;

  1701   inline bool has_download_request() const;

  1702   inline void clear_download_request();

  1703   static const int kDownloadRequestFieldNumber = 2;

  1704   inline const ::safe_browsing::ClientDownloadRequest& download_request() const;

  1705   inline ::safe_browsing::ClientDownloadRequest* mutable_download_request();

  1706   inline ::safe_browsing::ClientDownloadRequest* release_download_request();

  1708   // optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3;

  1709   inline bool has_user_information() const;

  1710   inline void clear_user_information();

  1711   static const int kUserInformationFieldNumber = 3;

  1712   inline const ::safe_browsing::ClientDownloadReport_UserInformation& user_information() const;

  1713   inline ::safe_browsing::ClientDownloadReport_UserInformation* mutable_user_information();

  1714   inline ::safe_browsing::ClientDownloadReport_UserInformation* release_user_information();

  1716   // optional bytes comment = 4;

  1717   inline bool has_comment() const;

  1718   inline void clear_comment();

  1719   static const int kCommentFieldNumber = 4;

  1720   inline const ::std::string& comment() const;

  1721   inline void set_comment(const ::std::string& value);

  1722   inline void set_comment(const char* value);

  1723   inline void set_comment(const void* value, size_t size);

  1724   inline ::std::string* mutable_comment();

  1725   inline ::std::string* release_comment();

  1727   // optional .safe_browsing.ClientDownloadResponse download_response = 5;

  1728   inline bool has_download_response() const;

  1729   inline void clear_download_response();

  1730   static const int kDownloadResponseFieldNumber = 5;

  1731   inline const ::safe_browsing::ClientDownloadResponse& download_response() const;

  1732   inline ::safe_browsing::ClientDownloadResponse* mutable_download_response();

  1733   inline ::safe_browsing::ClientDownloadResponse* release_download_response();

  1735   // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadReport)

  1736  private:

  1737   inline void set_has_reason();

  1738   inline void clear_has_reason();

  1739   inline void set_has_download_request();

  1740   inline void clear_has_download_request();

  1741   inline void set_has_user_information();

  1742   inline void clear_has_user_information();

  1743   inline void set_has_comment();

  1744   inline void clear_has_comment();

  1745   inline void set_has_download_response();

  1746   inline void clear_has_download_response();

  1748   ::safe_browsing::ClientDownloadRequest* download_request_;

  1749   ::safe_browsing::ClientDownloadReport_UserInformation* user_information_;

  1750   ::std::string* comment_;

  1751   ::safe_browsing::ClientDownloadResponse* download_response_;

  1752   int reason_;

  1754   mutable int _cached_size_;

  1755   ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  1757   friend void  protobuf_AddDesc_csd_2eproto();

  1758   friend void protobuf_AssignDesc_csd_2eproto();

  1759   friend void protobuf_ShutdownFile_csd_2eproto();

  1761   void InitAsDefaultInstance();

  1762   static ClientDownloadReport* default_instance_;

  1763 };

  1764 // -------------------------------------------------------------------

  1766 class ClientUploadResponse : public ::google::protobuf::MessageLite {

  1767  public:

  1768   ClientUploadResponse();

  1769   virtual ~ClientUploadResponse();

  1771   ClientUploadResponse(const ClientUploadResponse& from);

  1773   inline ClientUploadResponse& operator=(const ClientUploadResponse& from) {

  1774     CopyFrom(from);

  1775     return *this;

  1776   }

  1778   static const ClientUploadResponse& default_instance();

  1780   void Swap(ClientUploadResponse* other);

  1782   // implements Message ----------------------------------------------

  1784   ClientUploadResponse* New() const;

  1785   void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);

  1786   void CopyFrom(const ClientUploadResponse& from);

  1787   void MergeFrom(const ClientUploadResponse& from);

  1788   void Clear();

  1789   bool IsInitialized() const;

  1791   int ByteSize() const;

  1792   bool MergePartialFromCodedStream(

  1793       ::google::protobuf::io::CodedInputStream* input);

  1794   void SerializeWithCachedSizes(

  1795       ::google::protobuf::io::CodedOutputStream* output) const;

  1796   int GetCachedSize() const { return _cached_size_; }

  1797   private:

  1798   void SharedCtor();

  1799   void SharedDtor();

  1800   void SetCachedSize(int size) const;

  1801   public:

  1803   ::std::string GetTypeName() const;

  1805   // nested types ----------------------------------------------------

  1807   typedef ClientUploadResponse_UploadStatus UploadStatus;

  1808   static const UploadStatus SUCCESS = ClientUploadResponse_UploadStatus_SUCCESS;

  1809   static const UploadStatus UPLOAD_FAILURE = ClientUploadResponse_UploadStatus_UPLOAD_FAILURE;

  1810   static inline bool UploadStatus_IsValid(int value) {

  1811     return ClientUploadResponse_UploadStatus_IsValid(value);

  1812   }

  1813   static const UploadStatus UploadStatus_MIN =

  1814     ClientUploadResponse_UploadStatus_UploadStatus_MIN;

  1815   static const UploadStatus UploadStatus_MAX =

  1816     ClientUploadResponse_UploadStatus_UploadStatus_MAX;

  1817   static const int UploadStatus_ARRAYSIZE =

  1818     ClientUploadResponse_UploadStatus_UploadStatus_ARRAYSIZE;

  1820   // accessors -------------------------------------------------------

  1822   // optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1;

  1823   inline bool has_status() const;

  1824   inline void clear_status();

  1825   static const int kStatusFieldNumber = 1;

  1826   inline ::safe_browsing::ClientUploadResponse_UploadStatus status() const;

  1827   inline void set_status(::safe_browsing::ClientUploadResponse_UploadStatus value);

  1829   // optional string permalink = 2;

  1830   inline bool has_permalink() const;

  1831   inline void clear_permalink();

  1832   static const int kPermalinkFieldNumber = 2;

  1833   inline const ::std::string& permalink() const;

  1834   inline void set_permalink(const ::std::string& value);

  1835   inline void set_permalink(const char* value);

  1836   inline void set_permalink(const char* value, size_t size);

  1837   inline ::std::string* mutable_permalink();

  1838   inline ::std::string* release_permalink();

  1840   // @@protoc_insertion_point(class_scope:safe_browsing.ClientUploadResponse)

  1841  private:

  1842   inline void set_has_status();

  1843   inline void clear_has_status();

  1844   inline void set_has_permalink();

  1845   inline void clear_has_permalink();

  1847   ::std::string* permalink_;

  1848   int status_;

  1850   mutable int _cached_size_;

  1851   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  1853   friend void  protobuf_AddDesc_csd_2eproto();

  1854   friend void protobuf_AssignDesc_csd_2eproto();

  1855   friend void protobuf_ShutdownFile_csd_2eproto();

  1857   void InitAsDefaultInstance();

  1858   static ClientUploadResponse* default_instance_;

  1859 };

  1860 // ===================================================================

  1863 // ===================================================================

  1865 // ClientPhishingRequest_Feature

  1867 // required string name = 1;

  1868 inline bool ClientPhishingRequest_Feature::has_name() const {

  1869   return (_has_bits_[0] & 0x00000001u) != 0;

  1870 }

  1871 inline void ClientPhishingRequest_Feature::set_has_name() {

  1872   _has_bits_[0] |= 0x00000001u;

  1873 }

  1874 inline void ClientPhishingRequest_Feature::clear_has_name() {

  1875   _has_bits_[0] &= ~0x00000001u;

  1876 }

  1877 inline void ClientPhishingRequest_Feature::clear_name() {

  1878   if (name_ != &::google::protobuf::internal::kEmptyString) {

  1879     name_->clear();

  1880   }

  1881   clear_has_name();

  1882 }

  1883 inline const ::std::string& ClientPhishingRequest_Feature::name() const {

  1884   return *name_;

  1885 }

  1886 inline void ClientPhishingRequest_Feature::set_name(const ::std::string& value) {

  1887   set_has_name();

  1888   if (name_ == &::google::protobuf::internal::kEmptyString) {

  1889     name_ = new ::std::string;

  1890   }

  1891   name_->assign(value);

  1892 }

  1893 inline void ClientPhishingRequest_Feature::set_name(const char* value) {

  1894   set_has_name();

  1895   if (name_ == &::google::protobuf::internal::kEmptyString) {

  1896     name_ = new ::std::string;

  1897   }

  1898   name_->assign(value);

  1899 }

  1900 inline void ClientPhishingRequest_Feature::set_name(const char* value, size_t size) {

  1901   set_has_name();

  1902   if (name_ == &::google::protobuf::internal::kEmptyString) {

  1903     name_ = new ::std::string;

  1904   }

  1905   name_->assign(reinterpret_cast<const char*>(value), size);

  1906 }

  1907 inline ::std::string* ClientPhishingRequest_Feature::mutable_name() {

  1908   set_has_name();

  1909   if (name_ == &::google::protobuf::internal::kEmptyString) {

  1910     name_ = new ::std::string;

  1911   }

  1912   return name_;

  1913 }

  1914 inline ::std::string* ClientPhishingRequest_Feature::release_name() {

  1915   clear_has_name();

  1916   if (name_ == &::google::protobuf::internal::kEmptyString) {

  1917     return NULL;

  1918   } else {

  1919     ::std::string* temp = name_;

  1920     name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  1921     return temp;

  1922   }

  1923 }

  1925 // required double value = 2;

  1926 inline bool ClientPhishingRequest_Feature::has_value() const {

  1927   return (_has_bits_[0] & 0x00000002u) != 0;

  1928 }

  1929 inline void ClientPhishingRequest_Feature::set_has_value() {

  1930   _has_bits_[0] |= 0x00000002u;

  1931 }

  1932 inline void ClientPhishingRequest_Feature::clear_has_value() {

  1933   _has_bits_[0] &= ~0x00000002u;

  1934 }

  1935 inline void ClientPhishingRequest_Feature::clear_value() {

  1936   value_ = 0;

  1937   clear_has_value();

  1938 }

  1939 inline double ClientPhishingRequest_Feature::value() const {

  1940   return value_;

  1941 }

  1942 inline void ClientPhishingRequest_Feature::set_value(double value) {

  1943   set_has_value();

  1944   value_ = value;

  1945 }

  1947 // -------------------------------------------------------------------

  1949 // ClientPhishingRequest

  1951 // optional string url = 1;

  1952 inline bool ClientPhishingRequest::has_url() const {

  1953   return (_has_bits_[0] & 0x00000001u) != 0;

  1954 }

  1955 inline void ClientPhishingRequest::set_has_url() {

  1956   _has_bits_[0] |= 0x00000001u;

  1957 }

  1958 inline void ClientPhishingRequest::clear_has_url() {

  1959   _has_bits_[0] &= ~0x00000001u;

  1960 }

  1961 inline void ClientPhishingRequest::clear_url() {

  1962   if (url_ != &::google::protobuf::internal::kEmptyString) {

  1963     url_->clear();

  1964   }

  1965   clear_has_url();

  1966 }

  1967 inline const ::std::string& ClientPhishingRequest::url() const {

  1968   return *url_;

  1969 }

  1970 inline void ClientPhishingRequest::set_url(const ::std::string& value) {

  1971   set_has_url();

  1972   if (url_ == &::google::protobuf::internal::kEmptyString) {

  1973     url_ = new ::std::string;

  1974   }

  1975   url_->assign(value);

  1976 }

  1977 inline void ClientPhishingRequest::set_url(const char* value) {

  1978   set_has_url();

  1979   if (url_ == &::google::protobuf::internal::kEmptyString) {

  1980     url_ = new ::std::string;

  1981   }

  1982   url_->assign(value);

  1983 }

  1984 inline void ClientPhishingRequest::set_url(const char* value, size_t size) {

  1985   set_has_url();

  1986   if (url_ == &::google::protobuf::internal::kEmptyString) {

  1987     url_ = new ::std::string;

  1988   }

  1989   url_->assign(reinterpret_cast<const char*>(value), size);

  1990 }

  1991 inline ::std::string* ClientPhishingRequest::mutable_url() {

  1992   set_has_url();

  1993   if (url_ == &::google::protobuf::internal::kEmptyString) {

  1994     url_ = new ::std::string;

  1995   }

  1996   return url_;

  1997 }

  1998 inline ::std::string* ClientPhishingRequest::release_url() {

  1999   clear_has_url();

  2000   if (url_ == &::google::protobuf::internal::kEmptyString) {

  2001     return NULL;

  2002   } else {

  2003     ::std::string* temp = url_;

  2004     url_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  2005     return temp;

  2006   }

  2007 }

  2009 // optional bytes OBSOLETE_hash_prefix = 10;

  2010 inline bool ClientPhishingRequest::has_obsolete_hash_prefix() const {

  2011   return (_has_bits_[0] & 0x00000002u) != 0;

  2012 }

  2013 inline void ClientPhishingRequest::set_has_obsolete_hash_prefix() {

  2014   _has_bits_[0] |= 0x00000002u;

  2015 }

  2016 inline void ClientPhishingRequest::clear_has_obsolete_hash_prefix() {

  2017   _has_bits_[0] &= ~0x00000002u;

  2018 }

  2019 inline void ClientPhishingRequest::clear_obsolete_hash_prefix() {

  2020   if (obsolete_hash_prefix_ != &::google::protobuf::internal::kEmptyString) {

  2021     obsolete_hash_prefix_->clear();

  2022   }

  2023   clear_has_obsolete_hash_prefix();

  2024 }

  2025 inline const ::std::string& ClientPhishingRequest::obsolete_hash_prefix() const {

  2026   return *obsolete_hash_prefix_;

  2027 }

  2028 inline void ClientPhishingRequest::set_obsolete_hash_prefix(const ::std::string& value) {

  2029   set_has_obsolete_hash_prefix();

  2030   if (obsolete_hash_prefix_ == &::google::protobuf::internal::kEmptyString) {

  2031     obsolete_hash_prefix_ = new ::std::string;

  2032   }

  2033   obsolete_hash_prefix_->assign(value);

  2034 }

  2035 inline void ClientPhishingRequest::set_obsolete_hash_prefix(const char* value) {

  2036   set_has_obsolete_hash_prefix();

  2037   if (obsolete_hash_prefix_ == &::google::protobuf::internal::kEmptyString) {

  2038     obsolete_hash_prefix_ = new ::std::string;

  2039   }

  2040   obsolete_hash_prefix_->assign(value);

  2041 }

  2042 inline void ClientPhishingRequest::set_obsolete_hash_prefix(const void* value, size_t size) {

  2043   set_has_obsolete_hash_prefix();

  2044   if (obsolete_hash_prefix_ == &::google::protobuf::internal::kEmptyString) {

  2045     obsolete_hash_prefix_ = new ::std::string;

  2046   }

  2047   obsolete_hash_prefix_->assign(reinterpret_cast<const char*>(value), size);

  2048 }

  2049 inline ::std::string* ClientPhishingRequest::mutable_obsolete_hash_prefix() {

  2050   set_has_obsolete_hash_prefix();

  2051   if (obsolete_hash_prefix_ == &::google::protobuf::internal::kEmptyString) {

  2052     obsolete_hash_prefix_ = new ::std::string;

  2053   }

  2054   return obsolete_hash_prefix_;

  2055 }

  2056 inline ::std::string* ClientPhishingRequest::release_obsolete_hash_prefix() {

  2057   clear_has_obsolete_hash_prefix();

  2058   if (obsolete_hash_prefix_ == &::google::protobuf::internal::kEmptyString) {

  2059     return NULL;

  2060   } else {

  2061     ::std::string* temp = obsolete_hash_prefix_;

  2062     obsolete_hash_prefix_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  2063     return temp;

  2064   }

  2065 }

  2067 // required float client_score = 2;

  2068 inline bool ClientPhishingRequest::has_client_score() const {

  2069   return (_has_bits_[0] & 0x00000004u) != 0;

  2070 }

  2071 inline void ClientPhishingRequest::set_has_client_score() {

  2072   _has_bits_[0] |= 0x00000004u;

  2073 }

  2074 inline void ClientPhishingRequest::clear_has_client_score() {

  2075   _has_bits_[0] &= ~0x00000004u;

  2076 }

  2077 inline void ClientPhishingRequest::clear_client_score() {

  2078   client_score_ = 0;

  2079   clear_has_client_score();

  2080 }

  2081 inline float ClientPhishingRequest::client_score() const {

  2082   return client_score_;

  2083 }

  2084 inline void ClientPhishingRequest::set_client_score(float value) {

  2085   set_has_client_score();

  2086   client_score_ = value;

  2087 }

  2089 // optional bool is_phishing = 4;

  2090 inline bool ClientPhishingRequest::has_is_phishing() const {

  2091   return (_has_bits_[0] & 0x00000008u) != 0;

  2092 }

  2093 inline void ClientPhishingRequest::set_has_is_phishing() {

  2094   _has_bits_[0] |= 0x00000008u;

  2095 }

  2096 inline void ClientPhishingRequest::clear_has_is_phishing() {

  2097   _has_bits_[0] &= ~0x00000008u;

  2098 }

  2099 inline void ClientPhishingRequest::clear_is_phishing() {

  2100   is_phishing_ = false;

  2101   clear_has_is_phishing();

  2102 }

  2103 inline bool ClientPhishingRequest::is_phishing() const {

  2104   return is_phishing_;

  2105 }

  2106 inline void ClientPhishingRequest::set_is_phishing(bool value) {

  2107   set_has_is_phishing();

  2108   is_phishing_ = value;

  2109 }

  2111 // repeated .safe_browsing.ClientPhishingRequest.Feature feature_map = 5;

  2112 inline int ClientPhishingRequest::feature_map_size() const {

  2113   return feature_map_.size();

  2114 }

  2115 inline void ClientPhishingRequest::clear_feature_map() {

  2116   feature_map_.Clear();

  2117 }

  2118 inline const ::safe_browsing::ClientPhishingRequest_Feature& ClientPhishingRequest::feature_map(int index) const {

  2119   return feature_map_.Get(index);

  2120 }

  2121 inline ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::mutable_feature_map(int index) {

  2122   return feature_map_.Mutable(index);

  2123 }

  2124 inline ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::add_feature_map() {

  2125   return feature_map_.Add();

  2126 }

  2127 inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >&

  2128 ClientPhishingRequest::feature_map() const {

  2129   return feature_map_;

  2130 }

  2131 inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >*

  2132 ClientPhishingRequest::mutable_feature_map() {

  2133   return &feature_map_;

  2134 }

  2136 // optional int32 model_version = 6;

  2137 inline bool ClientPhishingRequest::has_model_version() const {

  2138   return (_has_bits_[0] & 0x00000020u) != 0;

  2139 }

  2140 inline void ClientPhishingRequest::set_has_model_version() {

  2141   _has_bits_[0] |= 0x00000020u;

  2142 }

  2143 inline void ClientPhishingRequest::clear_has_model_version() {

  2144   _has_bits_[0] &= ~0x00000020u;

  2145 }

  2146 inline void ClientPhishingRequest::clear_model_version() {

  2147   model_version_ = 0;

  2148   clear_has_model_version();

  2149 }

  2150 inline ::google::protobuf::int32 ClientPhishingRequest::model_version() const {

  2151   return model_version_;

  2152 }

  2153 inline void ClientPhishingRequest::set_model_version(::google::protobuf::int32 value) {

  2154   set_has_model_version();

  2155   model_version_ = value;

  2156 }

  2158 // repeated .safe_browsing.ClientPhishingRequest.Feature non_model_feature_map = 8;

  2159 inline int ClientPhishingRequest::non_model_feature_map_size() const {

  2160   return non_model_feature_map_.size();

  2161 }

  2162 inline void ClientPhishingRequest::clear_non_model_feature_map() {

  2163   non_model_feature_map_.Clear();

  2164 }

  2165 inline const ::safe_browsing::ClientPhishingRequest_Feature& ClientPhishingRequest::non_model_feature_map(int index) const {

  2166   return non_model_feature_map_.Get(index);

  2167 }

  2168 inline ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::mutable_non_model_feature_map(int index) {

  2169   return non_model_feature_map_.Mutable(index);

  2170 }

  2171 inline ::safe_browsing::ClientPhishingRequest_Feature* ClientPhishingRequest::add_non_model_feature_map() {

  2172   return non_model_feature_map_.Add();

  2173 }

  2174 inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >&

  2175 ClientPhishingRequest::non_model_feature_map() const {

  2176   return non_model_feature_map_;

  2177 }

  2178 inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientPhishingRequest_Feature >*

  2179 ClientPhishingRequest::mutable_non_model_feature_map() {

  2180   return &non_model_feature_map_;

  2181 }

  2183 // optional string OBSOLETE_referrer_url = 9;

  2184 inline bool ClientPhishingRequest::has_obsolete_referrer_url() const {

  2185   return (_has_bits_[0] & 0x00000080u) != 0;

  2186 }

  2187 inline void ClientPhishingRequest::set_has_obsolete_referrer_url() {

  2188   _has_bits_[0] |= 0x00000080u;

  2189 }

  2190 inline void ClientPhishingRequest::clear_has_obsolete_referrer_url() {

  2191   _has_bits_[0] &= ~0x00000080u;

  2192 }

  2193 inline void ClientPhishingRequest::clear_obsolete_referrer_url() {

  2194   if (obsolete_referrer_url_ != &::google::protobuf::internal::kEmptyString) {

  2195     obsolete_referrer_url_->clear();

  2196   }

  2197   clear_has_obsolete_referrer_url();

  2198 }

  2199 inline const ::std::string& ClientPhishingRequest::obsolete_referrer_url() const {

  2200   return *obsolete_referrer_url_;

  2201 }

  2202 inline void ClientPhishingRequest::set_obsolete_referrer_url(const ::std::string& value) {

  2203   set_has_obsolete_referrer_url();

  2204   if (obsolete_referrer_url_ == &::google::protobuf::internal::kEmptyString) {

  2205     obsolete_referrer_url_ = new ::std::string;

  2206   }

  2207   obsolete_referrer_url_->assign(value);

  2208 }

  2209 inline void ClientPhishingRequest::set_obsolete_referrer_url(const char* value) {

  2210   set_has_obsolete_referrer_url();

  2211   if (obsolete_referrer_url_ == &::google::protobuf::internal::kEmptyString) {

  2212     obsolete_referrer_url_ = new ::std::string;

  2213   }

  2214   obsolete_referrer_url_->assign(value);

  2215 }

  2216 inline void ClientPhishingRequest::set_obsolete_referrer_url(const char* value, size_t size) {

  2217   set_has_obsolete_referrer_url();

  2218   if (obsolete_referrer_url_ == &::google::protobuf::internal::kEmptyString) {

  2219     obsolete_referrer_url_ = new ::std::string;

  2220   }

  2221   obsolete_referrer_url_->assign(reinterpret_cast<const char*>(value), size);

  2222 }

  2223 inline ::std::string* ClientPhishingRequest::mutable_obsolete_referrer_url() {

  2224   set_has_obsolete_referrer_url();

  2225   if (obsolete_referrer_url_ == &::google::protobuf::internal::kEmptyString) {

  2226     obsolete_referrer_url_ = new ::std::string;

  2227   }

  2228   return obsolete_referrer_url_;

  2229 }

  2230 inline ::std::string* ClientPhishingRequest::release_obsolete_referrer_url() {

  2231   clear_has_obsolete_referrer_url();

  2232   if (obsolete_referrer_url_ == &::google::protobuf::internal::kEmptyString) {

  2233     return NULL;

  2234   } else {

  2235     ::std::string* temp = obsolete_referrer_url_;

  2236     obsolete_referrer_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  2237     return temp;

  2238   }

  2239 }

  2241 // -------------------------------------------------------------------

  2243 // ClientPhishingResponse

  2245 // required bool phishy = 1;

  2246 inline bool ClientPhishingResponse::has_phishy() const {

  2247   return (_has_bits_[0] & 0x00000001u) != 0;

  2248 }

  2249 inline void ClientPhishingResponse::set_has_phishy() {

  2250   _has_bits_[0] |= 0x00000001u;

  2251 }

  2252 inline void ClientPhishingResponse::clear_has_phishy() {

  2253   _has_bits_[0] &= ~0x00000001u;

  2254 }

  2255 inline void ClientPhishingResponse::clear_phishy() {

  2256   phishy_ = false;

  2257   clear_has_phishy();

  2258 }

  2259 inline bool ClientPhishingResponse::phishy() const {

  2260   return phishy_;

  2261 }

  2262 inline void ClientPhishingResponse::set_phishy(bool value) {

  2263   set_has_phishy();

  2264   phishy_ = value;

  2265 }

  2267 // repeated string OBSOLETE_whitelist_expression = 2;

  2268 inline int ClientPhishingResponse::obsolete_whitelist_expression_size() const {

  2269   return obsolete_whitelist_expression_.size();

  2270 }

  2271 inline void ClientPhishingResponse::clear_obsolete_whitelist_expression() {

  2272   obsolete_whitelist_expression_.Clear();

  2273 }

  2274 inline const ::std::string& ClientPhishingResponse::obsolete_whitelist_expression(int index) const {

  2275   return obsolete_whitelist_expression_.Get(index);

  2276 }

  2277 inline ::std::string* ClientPhishingResponse::mutable_obsolete_whitelist_expression(int index) {

  2278   return obsolete_whitelist_expression_.Mutable(index);

  2279 }

  2280 inline void ClientPhishingResponse::set_obsolete_whitelist_expression(int index, const ::std::string& value) {

  2281   obsolete_whitelist_expression_.Mutable(index)->assign(value);

  2282 }

  2283 inline void ClientPhishingResponse::set_obsolete_whitelist_expression(int index, const char* value) {

  2284   obsolete_whitelist_expression_.Mutable(index)->assign(value);

  2285 }

  2286 inline void ClientPhishingResponse::set_obsolete_whitelist_expression(int index, const char* value, size_t size) {

  2287   obsolete_whitelist_expression_.Mutable(index)->assign(

  2288     reinterpret_cast<const char*>(value), size);

  2289 }

  2290 inline ::std::string* ClientPhishingResponse::add_obsolete_whitelist_expression() {

  2291   return obsolete_whitelist_expression_.Add();

  2292 }

  2293 inline void ClientPhishingResponse::add_obsolete_whitelist_expression(const ::std::string& value) {

  2294   obsolete_whitelist_expression_.Add()->assign(value);

  2295 }

  2296 inline void ClientPhishingResponse::add_obsolete_whitelist_expression(const char* value) {

  2297   obsolete_whitelist_expression_.Add()->assign(value);

  2298 }

  2299 inline void ClientPhishingResponse::add_obsolete_whitelist_expression(const char* value, size_t size) {

  2300   obsolete_whitelist_expression_.Add()->assign(reinterpret_cast<const char*>(value), size);

  2301 }

  2302 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&

  2303 ClientPhishingResponse::obsolete_whitelist_expression() const {

  2304   return obsolete_whitelist_expression_;

  2305 }

  2306 inline ::google::protobuf::RepeatedPtrField< ::std::string>*

  2307 ClientPhishingResponse::mutable_obsolete_whitelist_expression() {

  2308   return &obsolete_whitelist_expression_;

  2309 }

  2311 // -------------------------------------------------------------------

  2313 // ClientMalwareRequest_Feature

  2315 // required string name = 1;

  2316 inline bool ClientMalwareRequest_Feature::has_name() const {

  2317   return (_has_bits_[0] & 0x00000001u) != 0;

  2318 }

  2319 inline void ClientMalwareRequest_Feature::set_has_name() {

  2320   _has_bits_[0] |= 0x00000001u;

  2321 }

  2322 inline void ClientMalwareRequest_Feature::clear_has_name() {

  2323   _has_bits_[0] &= ~0x00000001u;

  2324 }

  2325 inline void ClientMalwareRequest_Feature::clear_name() {

  2326   if (name_ != &::google::protobuf::internal::kEmptyString) {

  2327     name_->clear();

  2328   }

  2329   clear_has_name();

  2330 }

  2331 inline const ::std::string& ClientMalwareRequest_Feature::name() const {

  2332   return *name_;

  2333 }

  2334 inline void ClientMalwareRequest_Feature::set_name(const ::std::string& value) {

  2335   set_has_name();

  2336   if (name_ == &::google::protobuf::internal::kEmptyString) {

  2337     name_ = new ::std::string;

  2338   }

  2339   name_->assign(value);

  2340 }

  2341 inline void ClientMalwareRequest_Feature::set_name(const char* value) {

  2342   set_has_name();

  2343   if (name_ == &::google::protobuf::internal::kEmptyString) {

  2344     name_ = new ::std::string;

  2345   }

  2346   name_->assign(value);

  2347 }

  2348 inline void ClientMalwareRequest_Feature::set_name(const char* value, size_t size) {

  2349   set_has_name();

  2350   if (name_ == &::google::protobuf::internal::kEmptyString) {

  2351     name_ = new ::std::string;

  2352   }

  2353   name_->assign(reinterpret_cast<const char*>(value), size);

  2354 }

  2355 inline ::std::string* ClientMalwareRequest_Feature::mutable_name() {

  2356   set_has_name();

  2357   if (name_ == &::google::protobuf::internal::kEmptyString) {

  2358     name_ = new ::std::string;

  2359   }

  2360   return name_;

  2361 }

  2362 inline ::std::string* ClientMalwareRequest_Feature::release_name() {

  2363   clear_has_name();

  2364   if (name_ == &::google::protobuf::internal::kEmptyString) {

  2365     return NULL;

  2366   } else {

  2367     ::std::string* temp = name_;

  2368     name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  2369     return temp;

  2370   }

  2371 }

  2373 // required double value = 2;

  2374 inline bool ClientMalwareRequest_Feature::has_value() const {

  2375   return (_has_bits_[0] & 0x00000002u) != 0;

  2376 }

  2377 inline void ClientMalwareRequest_Feature::set_has_value() {

  2378   _has_bits_[0] |= 0x00000002u;

  2379 }

  2380 inline void ClientMalwareRequest_Feature::clear_has_value() {

  2381   _has_bits_[0] &= ~0x00000002u;

  2382 }

  2383 inline void ClientMalwareRequest_Feature::clear_value() {

  2384   value_ = 0;

  2385   clear_has_value();

  2386 }

  2387 inline double ClientMalwareRequest_Feature::value() const {

  2388   return value_;

  2389 }

  2390 inline void ClientMalwareRequest_Feature::set_value(double value) {

  2391   set_has_value();

  2392   value_ = value;

  2393 }

  2395 // repeated string metainfo = 3;

  2396 inline int ClientMalwareRequest_Feature::metainfo_size() const {

  2397   return metainfo_.size();

  2398 }

  2399 inline void ClientMalwareRequest_Feature::clear_metainfo() {

  2400   metainfo_.Clear();

  2401 }

  2402 inline const ::std::string& ClientMalwareRequest_Feature::metainfo(int index) const {

  2403   return metainfo_.Get(index);

  2404 }

  2405 inline ::std::string* ClientMalwareRequest_Feature::mutable_metainfo(int index) {

  2406   return metainfo_.Mutable(index);

  2407 }

  2408 inline void ClientMalwareRequest_Feature::set_metainfo(int index, const ::std::string& value) {

  2409   metainfo_.Mutable(index)->assign(value);

  2410 }

  2411 inline void ClientMalwareRequest_Feature::set_metainfo(int index, const char* value) {

  2412   metainfo_.Mutable(index)->assign(value);

  2413 }

  2414 inline void ClientMalwareRequest_Feature::set_metainfo(int index, const char* value, size_t size) {

  2415   metainfo_.Mutable(index)->assign(

  2416     reinterpret_cast<const char*>(value), size);

  2417 }

  2418 inline ::std::string* ClientMalwareRequest_Feature::add_metainfo() {

  2419   return metainfo_.Add();

  2420 }

  2421 inline void ClientMalwareRequest_Feature::add_metainfo(const ::std::string& value) {

  2422   metainfo_.Add()->assign(value);

  2423 }

  2424 inline void ClientMalwareRequest_Feature::add_metainfo(const char* value) {

  2425   metainfo_.Add()->assign(value);

  2426 }

  2427 inline void ClientMalwareRequest_Feature::add_metainfo(const char* value, size_t size) {

  2428   metainfo_.Add()->assign(reinterpret_cast<const char*>(value), size);

  2429 }

  2430 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&

  2431 ClientMalwareRequest_Feature::metainfo() const {

  2432   return metainfo_;

  2433 }

  2434 inline ::google::protobuf::RepeatedPtrField< ::std::string>*

  2435 ClientMalwareRequest_Feature::mutable_metainfo() {

  2436   return &metainfo_;

  2437 }

  2439 // -------------------------------------------------------------------

  2441 // ClientMalwareRequest

  2443 // required string url = 1;

  2444 inline bool ClientMalwareRequest::has_url() const {

  2445   return (_has_bits_[0] & 0x00000001u) != 0;

  2446 }

  2447 inline void ClientMalwareRequest::set_has_url() {

  2448   _has_bits_[0] |= 0x00000001u;

  2449 }

  2450 inline void ClientMalwareRequest::clear_has_url() {

  2451   _has_bits_[0] &= ~0x00000001u;

  2452 }

  2453 inline void ClientMalwareRequest::clear_url() {

  2454   if (url_ != &::google::protobuf::internal::kEmptyString) {

  2455     url_->clear();

  2456   }

  2457   clear_has_url();

  2458 }

  2459 inline const ::std::string& ClientMalwareRequest::url() const {

  2460   return *url_;

  2461 }

  2462 inline void ClientMalwareRequest::set_url(const ::std::string& value) {

  2463   set_has_url();

  2464   if (url_ == &::google::protobuf::internal::kEmptyString) {

  2465     url_ = new ::std::string;

  2466   }

  2467   url_->assign(value);

  2468 }

  2469 inline void ClientMalwareRequest::set_url(const char* value) {

  2470   set_has_url();

  2471   if (url_ == &::google::protobuf::internal::kEmptyString) {

  2472     url_ = new ::std::string;

  2473   }

  2474   url_->assign(value);

  2475 }

  2476 inline void ClientMalwareRequest::set_url(const char* value, size_t size) {

  2477   set_has_url();

  2478   if (url_ == &::google::protobuf::internal::kEmptyString) {

  2479     url_ = new ::std::string;

  2480   }

  2481   url_->assign(reinterpret_cast<const char*>(value), size);

  2482 }

  2483 inline ::std::string* ClientMalwareRequest::mutable_url() {

  2484   set_has_url();

  2485   if (url_ == &::google::protobuf::internal::kEmptyString) {

  2486     url_ = new ::std::string;

  2487   }

  2488   return url_;

  2489 }

  2490 inline ::std::string* ClientMalwareRequest::release_url() {

  2491   clear_has_url();

  2492   if (url_ == &::google::protobuf::internal::kEmptyString) {

  2493     return NULL;

  2494   } else {

  2495     ::std::string* temp = url_;

  2496     url_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  2497     return temp;

  2498   }

  2499 }

  2501 // repeated .safe_browsing.ClientMalwareRequest.Feature feature_map = 2;

  2502 inline int ClientMalwareRequest::feature_map_size() const {

  2503   return feature_map_.size();

  2504 }

  2505 inline void ClientMalwareRequest::clear_feature_map() {

  2506   feature_map_.Clear();

  2507 }

  2508 inline const ::safe_browsing::ClientMalwareRequest_Feature& ClientMalwareRequest::feature_map(int index) const {

  2509   return feature_map_.Get(index);

  2510 }

  2511 inline ::safe_browsing::ClientMalwareRequest_Feature* ClientMalwareRequest::mutable_feature_map(int index) {

  2512   return feature_map_.Mutable(index);

  2513 }

  2514 inline ::safe_browsing::ClientMalwareRequest_Feature* ClientMalwareRequest::add_feature_map() {

  2515   return feature_map_.Add();

  2516 }

  2517 inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_Feature >&

  2518 ClientMalwareRequest::feature_map() const {

  2519   return feature_map_;

  2520 }

  2521 inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_Feature >*

  2522 ClientMalwareRequest::mutable_feature_map() {

  2523   return &feature_map_;

  2524 }

  2526 // optional string referrer_url = 4;

  2527 inline bool ClientMalwareRequest::has_referrer_url() const {

  2528   return (_has_bits_[0] & 0x00000004u) != 0;

  2529 }

  2530 inline void ClientMalwareRequest::set_has_referrer_url() {

  2531   _has_bits_[0] |= 0x00000004u;

  2532 }

  2533 inline void ClientMalwareRequest::clear_has_referrer_url() {

  2534   _has_bits_[0] &= ~0x00000004u;

  2535 }

  2536 inline void ClientMalwareRequest::clear_referrer_url() {

  2537   if (referrer_url_ != &::google::protobuf::internal::kEmptyString) {

  2538     referrer_url_->clear();

  2539   }

  2540   clear_has_referrer_url();

  2541 }

  2542 inline const ::std::string& ClientMalwareRequest::referrer_url() const {

  2543   return *referrer_url_;

  2544 }

  2545 inline void ClientMalwareRequest::set_referrer_url(const ::std::string& value) {

  2546   set_has_referrer_url();

  2547   if (referrer_url_ == &::google::protobuf::internal::kEmptyString) {

  2548     referrer_url_ = new ::std::string;

  2549   }

  2550   referrer_url_->assign(value);

  2551 }

  2552 inline void ClientMalwareRequest::set_referrer_url(const char* value) {

  2553   set_has_referrer_url();

  2554   if (referrer_url_ == &::google::protobuf::internal::kEmptyString) {

  2555     referrer_url_ = new ::std::string;

  2556   }

  2557   referrer_url_->assign(value);

  2558 }

  2559 inline void ClientMalwareRequest::set_referrer_url(const char* value, size_t size) {

  2560   set_has_referrer_url();

  2561   if (referrer_url_ == &::google::protobuf::internal::kEmptyString) {

  2562     referrer_url_ = new ::std::string;

  2563   }

  2564   referrer_url_->assign(reinterpret_cast<const char*>(value), size);

  2565 }

  2566 inline ::std::string* ClientMalwareRequest::mutable_referrer_url() {

  2567   set_has_referrer_url();

  2568   if (referrer_url_ == &::google::protobuf::internal::kEmptyString) {

  2569     referrer_url_ = new ::std::string;

  2570   }

  2571   return referrer_url_;

  2572 }

  2573 inline ::std::string* ClientMalwareRequest::release_referrer_url() {

  2574   clear_has_referrer_url();

  2575   if (referrer_url_ == &::google::protobuf::internal::kEmptyString) {

  2576     return NULL;

  2577   } else {

  2578     ::std::string* temp = referrer_url_;

  2579     referrer_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  2580     return temp;

  2581   }

  2582 }

  2584 // -------------------------------------------------------------------

  2586 // ClientMalwareResponse

  2588 // required bool blacklist = 1;

  2589 inline bool ClientMalwareResponse::has_blacklist() const {

  2590   return (_has_bits_[0] & 0x00000001u) != 0;

  2591 }

  2592 inline void ClientMalwareResponse::set_has_blacklist() {

  2593   _has_bits_[0] |= 0x00000001u;

  2594 }

  2595 inline void ClientMalwareResponse::clear_has_blacklist() {

  2596   _has_bits_[0] &= ~0x00000001u;

  2597 }

  2598 inline void ClientMalwareResponse::clear_blacklist() {

  2599   blacklist_ = false;

  2600   clear_has_blacklist();

  2601 }

  2602 inline bool ClientMalwareResponse::blacklist() const {

  2603   return blacklist_;

  2604 }

  2605 inline void ClientMalwareResponse::set_blacklist(bool value) {

  2606   set_has_blacklist();

  2607   blacklist_ = value;

  2608 }

  2610 // optional string bad_ip = 2;

  2611 inline bool ClientMalwareResponse::has_bad_ip() const {

  2612   return (_has_bits_[0] & 0x00000002u) != 0;

  2613 }

  2614 inline void ClientMalwareResponse::set_has_bad_ip() {

  2615   _has_bits_[0] |= 0x00000002u;

  2616 }

  2617 inline void ClientMalwareResponse::clear_has_bad_ip() {

  2618   _has_bits_[0] &= ~0x00000002u;

  2619 }

  2620 inline void ClientMalwareResponse::clear_bad_ip() {

  2621   if (bad_ip_ != &::google::protobuf::internal::kEmptyString) {

  2622     bad_ip_->clear();

  2623   }

  2624   clear_has_bad_ip();

  2625 }

  2626 inline const ::std::string& ClientMalwareResponse::bad_ip() const {

  2627   return *bad_ip_;

  2628 }

  2629 inline void ClientMalwareResponse::set_bad_ip(const ::std::string& value) {

  2630   set_has_bad_ip();

  2631   if (bad_ip_ == &::google::protobuf::internal::kEmptyString) {

  2632     bad_ip_ = new ::std::string;

  2633   }

  2634   bad_ip_->assign(value);

  2635 }

  2636 inline void ClientMalwareResponse::set_bad_ip(const char* value) {

  2637   set_has_bad_ip();

  2638   if (bad_ip_ == &::google::protobuf::internal::kEmptyString) {

  2639     bad_ip_ = new ::std::string;

  2640   }

  2641   bad_ip_->assign(value);

  2642 }

  2643 inline void ClientMalwareResponse::set_bad_ip(const char* value, size_t size) {

  2644   set_has_bad_ip();

  2645   if (bad_ip_ == &::google::protobuf::internal::kEmptyString) {

  2646     bad_ip_ = new ::std::string;

  2647   }

  2648   bad_ip_->assign(reinterpret_cast<const char*>(value), size);

  2649 }

  2650 inline ::std::string* ClientMalwareResponse::mutable_bad_ip() {

  2651   set_has_bad_ip();

  2652   if (bad_ip_ == &::google::protobuf::internal::kEmptyString) {

  2653     bad_ip_ = new ::std::string;

  2654   }

  2655   return bad_ip_;

  2656 }

  2657 inline ::std::string* ClientMalwareResponse::release_bad_ip() {

  2658   clear_has_bad_ip();

  2659   if (bad_ip_ == &::google::protobuf::internal::kEmptyString) {

  2660     return NULL;

  2661   } else {

  2662     ::std::string* temp = bad_ip_;

  2663     bad_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  2664     return temp;

  2665   }

  2666 }

  2668 // -------------------------------------------------------------------

  2670 // ClientDownloadRequest_Digests

  2672 // optional bytes sha256 = 1;

  2673 inline bool ClientDownloadRequest_Digests::has_sha256() const {

  2674   return (_has_bits_[0] & 0x00000001u) != 0;

  2675 }

  2676 inline void ClientDownloadRequest_Digests::set_has_sha256() {

  2677   _has_bits_[0] |= 0x00000001u;

  2678 }

  2679 inline void ClientDownloadRequest_Digests::clear_has_sha256() {

  2680   _has_bits_[0] &= ~0x00000001u;

  2681 }

  2682 inline void ClientDownloadRequest_Digests::clear_sha256() {

  2683   if (sha256_ != &::google::protobuf::internal::kEmptyString) {

  2684     sha256_->clear();

  2685   }

  2686   clear_has_sha256();

  2687 }

  2688 inline const ::std::string& ClientDownloadRequest_Digests::sha256() const {

  2689   return *sha256_;

  2690 }

  2691 inline void ClientDownloadRequest_Digests::set_sha256(const ::std::string& value) {

  2692   set_has_sha256();

  2693   if (sha256_ == &::google::protobuf::internal::kEmptyString) {

  2694     sha256_ = new ::std::string;

  2695   }

  2696   sha256_->assign(value);

  2697 }

  2698 inline void ClientDownloadRequest_Digests::set_sha256(const char* value) {

  2699   set_has_sha256();

  2700   if (sha256_ == &::google::protobuf::internal::kEmptyString) {

  2701     sha256_ = new ::std::string;

  2702   }

  2703   sha256_->assign(value);

  2704 }

  2705 inline void ClientDownloadRequest_Digests::set_sha256(const void* value, size_t size) {

  2706   set_has_sha256();

  2707   if (sha256_ == &::google::protobuf::internal::kEmptyString) {

  2708     sha256_ = new ::std::string;

  2709   }

  2710   sha256_->assign(reinterpret_cast<const char*>(value), size);

  2711 }

  2712 inline ::std::string* ClientDownloadRequest_Digests::mutable_sha256() {

  2713   set_has_sha256();

  2714   if (sha256_ == &::google::protobuf::internal::kEmptyString) {

  2715     sha256_ = new ::std::string;

  2716   }

  2717   return sha256_;

  2718 }

  2719 inline ::std::string* ClientDownloadRequest_Digests::release_sha256() {

  2720   clear_has_sha256();

  2721   if (sha256_ == &::google::protobuf::internal::kEmptyString) {

  2722     return NULL;

  2723   } else {

  2724     ::std::string* temp = sha256_;

  2725     sha256_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  2726     return temp;

  2727   }

  2728 }

  2730 // optional bytes sha1 = 2;

  2731 inline bool ClientDownloadRequest_Digests::has_sha1() const {

  2732   return (_has_bits_[0] & 0x00000002u) != 0;

  2733 }

  2734 inline void ClientDownloadRequest_Digests::set_has_sha1() {

  2735   _has_bits_[0] |= 0x00000002u;

  2736 }

  2737 inline void ClientDownloadRequest_Digests::clear_has_sha1() {

  2738   _has_bits_[0] &= ~0x00000002u;

  2739 }

  2740 inline void ClientDownloadRequest_Digests::clear_sha1() {

  2741   if (sha1_ != &::google::protobuf::internal::kEmptyString) {

  2742     sha1_->clear();

  2743   }

  2744   clear_has_sha1();

  2745 }

  2746 inline const ::std::string& ClientDownloadRequest_Digests::sha1() const {

  2747   return *sha1_;

  2748 }

  2749 inline void ClientDownloadRequest_Digests::set_sha1(const ::std::string& value) {

  2750   set_has_sha1();

  2751   if (sha1_ == &::google::protobuf::internal::kEmptyString) {

  2752     sha1_ = new ::std::string;

  2753   }

  2754   sha1_->assign(value);

  2755 }

  2756 inline void ClientDownloadRequest_Digests::set_sha1(const char* value) {

  2757   set_has_sha1();

  2758   if (sha1_ == &::google::protobuf::internal::kEmptyString) {

  2759     sha1_ = new ::std::string;

  2760   }

  2761   sha1_->assign(value);

  2762 }

  2763 inline void ClientDownloadRequest_Digests::set_sha1(const void* value, size_t size) {

  2764   set_has_sha1();

  2765   if (sha1_ == &::google::protobuf::internal::kEmptyString) {

  2766     sha1_ = new ::std::string;

  2767   }

  2768   sha1_->assign(reinterpret_cast<const char*>(value), size);

  2769 }

  2770 inline ::std::string* ClientDownloadRequest_Digests::mutable_sha1() {

  2771   set_has_sha1();

  2772   if (sha1_ == &::google::protobuf::internal::kEmptyString) {

  2773     sha1_ = new ::std::string;

  2774   }

  2775   return sha1_;

  2776 }

  2777 inline ::std::string* ClientDownloadRequest_Digests::release_sha1() {

  2778   clear_has_sha1();

  2779   if (sha1_ == &::google::protobuf::internal::kEmptyString) {

  2780     return NULL;

  2781   } else {

  2782     ::std::string* temp = sha1_;

  2783     sha1_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  2784     return temp;

  2785   }

  2786 }

  2788 // optional bytes md5 = 3;

  2789 inline bool ClientDownloadRequest_Digests::has_md5() const {

  2790   return (_has_bits_[0] & 0x00000004u) != 0;

  2791 }

  2792 inline void ClientDownloadRequest_Digests::set_has_md5() {

  2793   _has_bits_[0] |= 0x00000004u;

  2794 }

  2795 inline void ClientDownloadRequest_Digests::clear_has_md5() {

  2796   _has_bits_[0] &= ~0x00000004u;

  2797 }

  2798 inline void ClientDownloadRequest_Digests::clear_md5() {

  2799   if (md5_ != &::google::protobuf::internal::kEmptyString) {

  2800     md5_->clear();

  2801   }

  2802   clear_has_md5();

  2803 }

  2804 inline const ::std::string& ClientDownloadRequest_Digests::md5() const {

  2805   return *md5_;

  2806 }

  2807 inline void ClientDownloadRequest_Digests::set_md5(const ::std::string& value) {

  2808   set_has_md5();

  2809   if (md5_ == &::google::protobuf::internal::kEmptyString) {

  2810     md5_ = new ::std::string;

  2811   }

  2812   md5_->assign(value);

  2813 }

  2814 inline void ClientDownloadRequest_Digests::set_md5(const char* value) {

  2815   set_has_md5();

  2816   if (md5_ == &::google::protobuf::internal::kEmptyString) {

  2817     md5_ = new ::std::string;

  2818   }

  2819   md5_->assign(value);

  2820 }

  2821 inline void ClientDownloadRequest_Digests::set_md5(const void* value, size_t size) {

  2822   set_has_md5();

  2823   if (md5_ == &::google::protobuf::internal::kEmptyString) {

  2824     md5_ = new ::std::string;

  2825   }

  2826   md5_->assign(reinterpret_cast<const char*>(value), size);

  2827 }

  2828 inline ::std::string* ClientDownloadRequest_Digests::mutable_md5() {

  2829   set_has_md5();

  2830   if (md5_ == &::google::protobuf::internal::kEmptyString) {

  2831     md5_ = new ::std::string;

  2832   }

  2833   return md5_;

  2834 }

  2835 inline ::std::string* ClientDownloadRequest_Digests::release_md5() {

  2836   clear_has_md5();

  2837   if (md5_ == &::google::protobuf::internal::kEmptyString) {

  2838     return NULL;

  2839   } else {

  2840     ::std::string* temp = md5_;

  2841     md5_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  2842     return temp;

  2843   }

  2844 }

  2846 // -------------------------------------------------------------------

  2848 // ClientDownloadRequest_Resource

  2850 // required string url = 1;

  2851 inline bool ClientDownloadRequest_Resource::has_url() const {

  2852   return (_has_bits_[0] & 0x00000001u) != 0;

  2853 }

  2854 inline void ClientDownloadRequest_Resource::set_has_url() {

  2855   _has_bits_[0] |= 0x00000001u;

  2856 }

  2857 inline void ClientDownloadRequest_Resource::clear_has_url() {

  2858   _has_bits_[0] &= ~0x00000001u;

  2859 }

  2860 inline void ClientDownloadRequest_Resource::clear_url() {

  2861   if (url_ != &::google::protobuf::internal::kEmptyString) {

  2862     url_->clear();

  2863   }

  2864   clear_has_url();

  2865 }

  2866 inline const ::std::string& ClientDownloadRequest_Resource::url() const {

  2867   return *url_;

  2868 }

  2869 inline void ClientDownloadRequest_Resource::set_url(const ::std::string& value) {

  2870   set_has_url();

  2871   if (url_ == &::google::protobuf::internal::kEmptyString) {

  2872     url_ = new ::std::string;

  2873   }

  2874   url_->assign(value);

  2875 }

  2876 inline void ClientDownloadRequest_Resource::set_url(const char* value) {

  2877   set_has_url();

  2878   if (url_ == &::google::protobuf::internal::kEmptyString) {

  2879     url_ = new ::std::string;

  2880   }

  2881   url_->assign(value);

  2882 }

  2883 inline void ClientDownloadRequest_Resource::set_url(const char* value, size_t size) {

  2884   set_has_url();

  2885   if (url_ == &::google::protobuf::internal::kEmptyString) {

  2886     url_ = new ::std::string;

  2887   }

  2888   url_->assign(reinterpret_cast<const char*>(value), size);

  2889 }

  2890 inline ::std::string* ClientDownloadRequest_Resource::mutable_url() {

  2891   set_has_url();

  2892   if (url_ == &::google::protobuf::internal::kEmptyString) {

  2893     url_ = new ::std::string;

  2894   }

  2895   return url_;

  2896 }

  2897 inline ::std::string* ClientDownloadRequest_Resource::release_url() {

  2898   clear_has_url();

  2899   if (url_ == &::google::protobuf::internal::kEmptyString) {

  2900     return NULL;

  2901   } else {

  2902     ::std::string* temp = url_;

  2903     url_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  2904     return temp;

  2905   }

  2906 }

  2908 // required .safe_browsing.ClientDownloadRequest.ResourceType type = 2;

  2909 inline bool ClientDownloadRequest_Resource::has_type() const {

  2910   return (_has_bits_[0] & 0x00000002u) != 0;

  2911 }

  2912 inline void ClientDownloadRequest_Resource::set_has_type() {

  2913   _has_bits_[0] |= 0x00000002u;

  2914 }

  2915 inline void ClientDownloadRequest_Resource::clear_has_type() {

  2916   _has_bits_[0] &= ~0x00000002u;

  2917 }

  2918 inline void ClientDownloadRequest_Resource::clear_type() {

  2919   type_ = 0;

  2920   clear_has_type();

  2921 }

  2922 inline ::safe_browsing::ClientDownloadRequest_ResourceType ClientDownloadRequest_Resource::type() const {

  2923   return static_cast< ::safe_browsing::ClientDownloadRequest_ResourceType >(type_);

  2924 }

  2925 inline void ClientDownloadRequest_Resource::set_type(::safe_browsing::ClientDownloadRequest_ResourceType value) {

  2926   GOOGLE_DCHECK(::safe_browsing::ClientDownloadRequest_ResourceType_IsValid(value));

  2927   set_has_type();

  2928   type_ = value;

  2929 }

  2931 // optional bytes remote_ip = 3;

  2932 inline bool ClientDownloadRequest_Resource::has_remote_ip() const {

  2933   return (_has_bits_[0] & 0x00000004u) != 0;

  2934 }

  2935 inline void ClientDownloadRequest_Resource::set_has_remote_ip() {

  2936   _has_bits_[0] |= 0x00000004u;

  2937 }

  2938 inline void ClientDownloadRequest_Resource::clear_has_remote_ip() {

  2939   _has_bits_[0] &= ~0x00000004u;

  2940 }

  2941 inline void ClientDownloadRequest_Resource::clear_remote_ip() {

  2942   if (remote_ip_ != &::google::protobuf::internal::kEmptyString) {

  2943     remote_ip_->clear();

  2944   }

  2945   clear_has_remote_ip();

  2946 }

  2947 inline const ::std::string& ClientDownloadRequest_Resource::remote_ip() const {

  2948   return *remote_ip_;

  2949 }

  2950 inline void ClientDownloadRequest_Resource::set_remote_ip(const ::std::string& value) {

  2951   set_has_remote_ip();

  2952   if (remote_ip_ == &::google::protobuf::internal::kEmptyString) {

  2953     remote_ip_ = new ::std::string;

  2954   }

  2955   remote_ip_->assign(value);

  2956 }

  2957 inline void ClientDownloadRequest_Resource::set_remote_ip(const char* value) {

  2958   set_has_remote_ip();

  2959   if (remote_ip_ == &::google::protobuf::internal::kEmptyString) {

  2960     remote_ip_ = new ::std::string;

  2961   }

  2962   remote_ip_->assign(value);

  2963 }

  2964 inline void ClientDownloadRequest_Resource::set_remote_ip(const void* value, size_t size) {

  2965   set_has_remote_ip();

  2966   if (remote_ip_ == &::google::protobuf::internal::kEmptyString) {

  2967     remote_ip_ = new ::std::string;

  2968   }

  2969   remote_ip_->assign(reinterpret_cast<const char*>(value), size);

  2970 }

  2971 inline ::std::string* ClientDownloadRequest_Resource::mutable_remote_ip() {

  2972   set_has_remote_ip();

  2973   if (remote_ip_ == &::google::protobuf::internal::kEmptyString) {

  2974     remote_ip_ = new ::std::string;

  2975   }

  2976   return remote_ip_;

  2977 }

  2978 inline ::std::string* ClientDownloadRequest_Resource::release_remote_ip() {

  2979   clear_has_remote_ip();

  2980   if (remote_ip_ == &::google::protobuf::internal::kEmptyString) {

  2981     return NULL;

  2982   } else {

  2983     ::std::string* temp = remote_ip_;

  2984     remote_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  2985     return temp;

  2986   }

  2987 }

  2989 // optional string referrer = 4;

  2990 inline bool ClientDownloadRequest_Resource::has_referrer() const {

  2991   return (_has_bits_[0] & 0x00000008u) != 0;

  2992 }

  2993 inline void ClientDownloadRequest_Resource::set_has_referrer() {

  2994   _has_bits_[0] |= 0x00000008u;

  2995 }

  2996 inline void ClientDownloadRequest_Resource::clear_has_referrer() {

  2997   _has_bits_[0] &= ~0x00000008u;

  2998 }

  2999 inline void ClientDownloadRequest_Resource::clear_referrer() {

  3000   if (referrer_ != &::google::protobuf::internal::kEmptyString) {

  3001     referrer_->clear();

  3002   }

  3003   clear_has_referrer();

  3004 }

  3005 inline const ::std::string& ClientDownloadRequest_Resource::referrer() const {

  3006   return *referrer_;

  3007 }

  3008 inline void ClientDownloadRequest_Resource::set_referrer(const ::std::string& value) {

  3009   set_has_referrer();

  3010   if (referrer_ == &::google::protobuf::internal::kEmptyString) {

  3011     referrer_ = new ::std::string;

  3012   }

  3013   referrer_->assign(value);

  3014 }

  3015 inline void ClientDownloadRequest_Resource::set_referrer(const char* value) {

  3016   set_has_referrer();

  3017   if (referrer_ == &::google::protobuf::internal::kEmptyString) {

  3018     referrer_ = new ::std::string;

  3019   }

  3020   referrer_->assign(value);

  3021 }

  3022 inline void ClientDownloadRequest_Resource::set_referrer(const char* value, size_t size) {

  3023   set_has_referrer();

  3024   if (referrer_ == &::google::protobuf::internal::kEmptyString) {

  3025     referrer_ = new ::std::string;

  3026   }

  3027   referrer_->assign(reinterpret_cast<const char*>(value), size);

  3028 }

  3029 inline ::std::string* ClientDownloadRequest_Resource::mutable_referrer() {

  3030   set_has_referrer();

  3031   if (referrer_ == &::google::protobuf::internal::kEmptyString) {

  3032     referrer_ = new ::std::string;

  3033   }

  3034   return referrer_;

  3035 }

  3036 inline ::std::string* ClientDownloadRequest_Resource::release_referrer() {

  3037   clear_has_referrer();

  3038   if (referrer_ == &::google::protobuf::internal::kEmptyString) {

  3039     return NULL;

  3040   } else {

  3041     ::std::string* temp = referrer_;

  3042     referrer_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  3043     return temp;

  3044   }

  3045 }

  3047 // -------------------------------------------------------------------

  3049 // ClientDownloadRequest_CertificateChain_Element

  3051 // optional bytes certificate = 1;

  3052 inline bool ClientDownloadRequest_CertificateChain_Element::has_certificate() const {

  3053   return (_has_bits_[0] & 0x00000001u) != 0;

  3054 }

  3055 inline void ClientDownloadRequest_CertificateChain_Element::set_has_certificate() {

  3056   _has_bits_[0] |= 0x00000001u;

  3057 }

  3058 inline void ClientDownloadRequest_CertificateChain_Element::clear_has_certificate() {

  3059   _has_bits_[0] &= ~0x00000001u;

  3060 }

  3061 inline void ClientDownloadRequest_CertificateChain_Element::clear_certificate() {

  3062   if (certificate_ != &::google::protobuf::internal::kEmptyString) {

  3063     certificate_->clear();

  3064   }

  3065   clear_has_certificate();

  3066 }

  3067 inline const ::std::string& ClientDownloadRequest_CertificateChain_Element::certificate() const {

  3068   return *certificate_;

  3069 }

  3070 inline void ClientDownloadRequest_CertificateChain_Element::set_certificate(const ::std::string& value) {

  3071   set_has_certificate();

  3072   if (certificate_ == &::google::protobuf::internal::kEmptyString) {

  3073     certificate_ = new ::std::string;

  3074   }

  3075   certificate_->assign(value);

  3076 }

  3077 inline void ClientDownloadRequest_CertificateChain_Element::set_certificate(const char* value) {

  3078   set_has_certificate();

  3079   if (certificate_ == &::google::protobuf::internal::kEmptyString) {

  3080     certificate_ = new ::std::string;

  3081   }

  3082   certificate_->assign(value);

  3083 }

  3084 inline void ClientDownloadRequest_CertificateChain_Element::set_certificate(const void* value, size_t size) {

  3085   set_has_certificate();

  3086   if (certificate_ == &::google::protobuf::internal::kEmptyString) {

  3087     certificate_ = new ::std::string;

  3088   }

  3089   certificate_->assign(reinterpret_cast<const char*>(value), size);

  3090 }

  3091 inline ::std::string* ClientDownloadRequest_CertificateChain_Element::mutable_certificate() {

  3092   set_has_certificate();

  3093   if (certificate_ == &::google::protobuf::internal::kEmptyString) {

  3094     certificate_ = new ::std::string;

  3095   }

  3096   return certificate_;

  3097 }

  3098 inline ::std::string* ClientDownloadRequest_CertificateChain_Element::release_certificate() {

  3099   clear_has_certificate();

  3100   if (certificate_ == &::google::protobuf::internal::kEmptyString) {

  3101     return NULL;

  3102   } else {

  3103     ::std::string* temp = certificate_;

  3104     certificate_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  3105     return temp;

  3106   }

  3107 }

  3109 // -------------------------------------------------------------------

  3111 // ClientDownloadRequest_CertificateChain

  3113 // repeated .safe_browsing.ClientDownloadRequest.CertificateChain.Element element = 1;

  3114 inline int ClientDownloadRequest_CertificateChain::element_size() const {

  3115   return element_.size();

  3116 }

  3117 inline void ClientDownloadRequest_CertificateChain::clear_element() {

  3118   element_.Clear();

  3119 }

  3120 inline const ::safe_browsing::ClientDownloadRequest_CertificateChain_Element& ClientDownloadRequest_CertificateChain::element(int index) const {

  3121   return element_.Get(index);

  3122 }

  3123 inline ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* ClientDownloadRequest_CertificateChain::mutable_element(int index) {

  3124   return element_.Mutable(index);

  3125 }

  3126 inline ::safe_browsing::ClientDownloadRequest_CertificateChain_Element* ClientDownloadRequest_CertificateChain::add_element() {

  3127   return element_.Add();

  3128 }

  3129 inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >&

  3130 ClientDownloadRequest_CertificateChain::element() const {

  3131   return element_;

  3132 }

  3133 inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element >*

  3134 ClientDownloadRequest_CertificateChain::mutable_element() {

  3135   return &element_;

  3136 }

  3138 // -------------------------------------------------------------------

  3140 // ClientDownloadRequest_SignatureInfo

  3142 // repeated .safe_browsing.ClientDownloadRequest.CertificateChain certificate_chain = 1;

  3143 inline int ClientDownloadRequest_SignatureInfo::certificate_chain_size() const {

  3144   return certificate_chain_.size();

  3145 }

  3146 inline void ClientDownloadRequest_SignatureInfo::clear_certificate_chain() {

  3147   certificate_chain_.Clear();

  3148 }

  3149 inline const ::safe_browsing::ClientDownloadRequest_CertificateChain& ClientDownloadRequest_SignatureInfo::certificate_chain(int index) const {

  3150   return certificate_chain_.Get(index);

  3151 }

  3152 inline ::safe_browsing::ClientDownloadRequest_CertificateChain* ClientDownloadRequest_SignatureInfo::mutable_certificate_chain(int index) {

  3153   return certificate_chain_.Mutable(index);

  3154 }

  3155 inline ::safe_browsing::ClientDownloadRequest_CertificateChain* ClientDownloadRequest_SignatureInfo::add_certificate_chain() {

  3156   return certificate_chain_.Add();

  3157 }

  3158 inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain >&

  3159 ClientDownloadRequest_SignatureInfo::certificate_chain() const {

  3160   return certificate_chain_;

  3161 }

  3162 inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain >*

  3163 ClientDownloadRequest_SignatureInfo::mutable_certificate_chain() {

  3164   return &certificate_chain_;

  3165 }

  3167 // optional bool trusted = 2;

  3168 inline bool ClientDownloadRequest_SignatureInfo::has_trusted() const {

  3169   return (_has_bits_[0] & 0x00000002u) != 0;

  3170 }

  3171 inline void ClientDownloadRequest_SignatureInfo::set_has_trusted() {

  3172   _has_bits_[0] |= 0x00000002u;

  3173 }

  3174 inline void ClientDownloadRequest_SignatureInfo::clear_has_trusted() {

  3175   _has_bits_[0] &= ~0x00000002u;

  3176 }

  3177 inline void ClientDownloadRequest_SignatureInfo::clear_trusted() {

  3178   trusted_ = false;

  3179   clear_has_trusted();

  3180 }

  3181 inline bool ClientDownloadRequest_SignatureInfo::trusted() const {

  3182   return trusted_;

  3183 }

  3184 inline void ClientDownloadRequest_SignatureInfo::set_trusted(bool value) {

  3185   set_has_trusted();

  3186   trusted_ = value;

  3187 }

  3189 // -------------------------------------------------------------------

  3191 // ClientDownloadRequest

  3193 // required string url = 1;

  3194 inline bool ClientDownloadRequest::has_url() const {

  3195   return (_has_bits_[0] & 0x00000001u) != 0;

  3196 }

  3197 inline void ClientDownloadRequest::set_has_url() {

  3198   _has_bits_[0] |= 0x00000001u;

  3199 }

  3200 inline void ClientDownloadRequest::clear_has_url() {

  3201   _has_bits_[0] &= ~0x00000001u;

  3202 }

  3203 inline void ClientDownloadRequest::clear_url() {

  3204   if (url_ != &::google::protobuf::internal::kEmptyString) {

  3205     url_->clear();

  3206   }

  3207   clear_has_url();

  3208 }

  3209 inline const ::std::string& ClientDownloadRequest::url() const {

  3210   return *url_;

  3211 }

  3212 inline void ClientDownloadRequest::set_url(const ::std::string& value) {

  3213   set_has_url();

  3214   if (url_ == &::google::protobuf::internal::kEmptyString) {

  3215     url_ = new ::std::string;

  3216   }

  3217   url_->assign(value);

  3218 }

  3219 inline void ClientDownloadRequest::set_url(const char* value) {

  3220   set_has_url();

  3221   if (url_ == &::google::protobuf::internal::kEmptyString) {

  3222     url_ = new ::std::string;

  3223   }

  3224   url_->assign(value);

  3225 }

  3226 inline void ClientDownloadRequest::set_url(const char* value, size_t size) {

  3227   set_has_url();

  3228   if (url_ == &::google::protobuf::internal::kEmptyString) {

  3229     url_ = new ::std::string;

  3230   }

  3231   url_->assign(reinterpret_cast<const char*>(value), size);

  3232 }

  3233 inline ::std::string* ClientDownloadRequest::mutable_url() {

  3234   set_has_url();

  3235   if (url_ == &::google::protobuf::internal::kEmptyString) {

  3236     url_ = new ::std::string;

  3237   }

  3238   return url_;

  3239 }

  3240 inline ::std::string* ClientDownloadRequest::release_url() {

  3241   clear_has_url();

  3242   if (url_ == &::google::protobuf::internal::kEmptyString) {

  3243     return NULL;

  3244   } else {

  3245     ::std::string* temp = url_;

  3246     url_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  3247     return temp;

  3248   }

  3249 }

  3251 // required .safe_browsing.ClientDownloadRequest.Digests digests = 2;

  3252 inline bool ClientDownloadRequest::has_digests() const {

  3253   return (_has_bits_[0] & 0x00000002u) != 0;

  3254 }

  3255 inline void ClientDownloadRequest::set_has_digests() {

  3256   _has_bits_[0] |= 0x00000002u;

  3257 }

  3258 inline void ClientDownloadRequest::clear_has_digests() {

  3259   _has_bits_[0] &= ~0x00000002u;

  3260 }

  3261 inline void ClientDownloadRequest::clear_digests() {

  3262   if (digests_ != NULL) digests_->::safe_browsing::ClientDownloadRequest_Digests::Clear();

  3263   clear_has_digests();

  3264 }

  3265 inline const ::safe_browsing::ClientDownloadRequest_Digests& ClientDownloadRequest::digests() const {

  3266   return digests_ != NULL ? *digests_ : *default_instance_->digests_;

  3267 }

  3268 inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest::mutable_digests() {

  3269   set_has_digests();

  3270   if (digests_ == NULL) digests_ = new ::safe_browsing::ClientDownloadRequest_Digests;

  3271   return digests_;

  3272 }

  3273 inline ::safe_browsing::ClientDownloadRequest_Digests* ClientDownloadRequest::release_digests() {

  3274   clear_has_digests();

  3275   ::safe_browsing::ClientDownloadRequest_Digests* temp = digests_;

  3276   digests_ = NULL;

  3277   return temp;

  3278 }

  3280 // required int64 length = 3;

  3281 inline bool ClientDownloadRequest::has_length() const {

  3282   return (_has_bits_[0] & 0x00000004u) != 0;

  3283 }

  3284 inline void ClientDownloadRequest::set_has_length() {

  3285   _has_bits_[0] |= 0x00000004u;

  3286 }

  3287 inline void ClientDownloadRequest::clear_has_length() {

  3288   _has_bits_[0] &= ~0x00000004u;

  3289 }

  3290 inline void ClientDownloadRequest::clear_length() {

  3291   length_ = GOOGLE_LONGLONG(0);

  3292   clear_has_length();

  3293 }

  3294 inline ::google::protobuf::int64 ClientDownloadRequest::length() const {

  3295   return length_;

  3296 }

  3297 inline void ClientDownloadRequest::set_length(::google::protobuf::int64 value) {

  3298   set_has_length();

  3299   length_ = value;

  3300 }

  3302 // repeated .safe_browsing.ClientDownloadRequest.Resource resources = 4;

  3303 inline int ClientDownloadRequest::resources_size() const {

  3304   return resources_.size();

  3305 }

  3306 inline void ClientDownloadRequest::clear_resources() {

  3307   resources_.Clear();

  3308 }

  3309 inline const ::safe_browsing::ClientDownloadRequest_Resource& ClientDownloadRequest::resources(int index) const {

  3310   return resources_.Get(index);

  3311 }

  3312 inline ::safe_browsing::ClientDownloadRequest_Resource* ClientDownloadRequest::mutable_resources(int index) {

  3313   return resources_.Mutable(index);

  3314 }

  3315 inline ::safe_browsing::ClientDownloadRequest_Resource* ClientDownloadRequest::add_resources() {

  3316   return resources_.Add();

  3317 }

  3318 inline const ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource >&

  3319 ClientDownloadRequest::resources() const {

  3320   return resources_;

  3321 }

  3322 inline ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_Resource >*

  3323 ClientDownloadRequest::mutable_resources() {

  3324   return &resources_;

  3325 }

  3327 // optional .safe_browsing.ClientDownloadRequest.SignatureInfo signature = 5;

  3328 inline bool ClientDownloadRequest::has_signature() const {

  3329   return (_has_bits_[0] & 0x00000010u) != 0;

  3330 }

  3331 inline void ClientDownloadRequest::set_has_signature() {

  3332   _has_bits_[0] |= 0x00000010u;

  3333 }

  3334 inline void ClientDownloadRequest::clear_has_signature() {

  3335   _has_bits_[0] &= ~0x00000010u;

  3336 }

  3337 inline void ClientDownloadRequest::clear_signature() {

  3338   if (signature_ != NULL) signature_->::safe_browsing::ClientDownloadRequest_SignatureInfo::Clear();

  3339   clear_has_signature();

  3340 }

  3341 inline const ::safe_browsing::ClientDownloadRequest_SignatureInfo& ClientDownloadRequest::signature() const {

  3342   return signature_ != NULL ? *signature_ : *default_instance_->signature_;

  3343 }

  3344 inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest::mutable_signature() {

  3345   set_has_signature();

  3346   if (signature_ == NULL) signature_ = new ::safe_browsing::ClientDownloadRequest_SignatureInfo;

  3347   return signature_;

  3348 }

  3349 inline ::safe_browsing::ClientDownloadRequest_SignatureInfo* ClientDownloadRequest::release_signature() {

  3350   clear_has_signature();

  3351   ::safe_browsing::ClientDownloadRequest_SignatureInfo* temp = signature_;

  3352   signature_ = NULL;

  3353   return temp;

  3354 }

  3356 // optional bool user_initiated = 6;

  3357 inline bool ClientDownloadRequest::has_user_initiated() const {

  3358   return (_has_bits_[0] & 0x00000020u) != 0;

  3359 }

  3360 inline void ClientDownloadRequest::set_has_user_initiated() {

  3361   _has_bits_[0] |= 0x00000020u;

  3362 }

  3363 inline void ClientDownloadRequest::clear_has_user_initiated() {

  3364   _has_bits_[0] &= ~0x00000020u;

  3365 }

  3366 inline void ClientDownloadRequest::clear_user_initiated() {

  3367   user_initiated_ = false;

  3368   clear_has_user_initiated();

  3369 }

  3370 inline bool ClientDownloadRequest::user_initiated() const {

  3371   return user_initiated_;

  3372 }

  3373 inline void ClientDownloadRequest::set_user_initiated(bool value) {

  3374   set_has_user_initiated();

  3375   user_initiated_ = value;

  3376 }

  3378 // optional string file_basename = 9;

  3379 inline bool ClientDownloadRequest::has_file_basename() const {

  3380   return (_has_bits_[0] & 0x00000040u) != 0;

  3381 }

  3382 inline void ClientDownloadRequest::set_has_file_basename() {

  3383   _has_bits_[0] |= 0x00000040u;

  3384 }

  3385 inline void ClientDownloadRequest::clear_has_file_basename() {

  3386   _has_bits_[0] &= ~0x00000040u;

  3387 }

  3388 inline void ClientDownloadRequest::clear_file_basename() {

  3389   if (file_basename_ != &::google::protobuf::internal::kEmptyString) {

  3390     file_basename_->clear();

  3391   }

  3392   clear_has_file_basename();

  3393 }

  3394 inline const ::std::string& ClientDownloadRequest::file_basename() const {

  3395   return *file_basename_;

  3396 }

  3397 inline void ClientDownloadRequest::set_file_basename(const ::std::string& value) {

  3398   set_has_file_basename();

  3399   if (file_basename_ == &::google::protobuf::internal::kEmptyString) {

  3400     file_basename_ = new ::std::string;

  3401   }

  3402   file_basename_->assign(value);

  3403 }

  3404 inline void ClientDownloadRequest::set_file_basename(const char* value) {

  3405   set_has_file_basename();

  3406   if (file_basename_ == &::google::protobuf::internal::kEmptyString) {

  3407     file_basename_ = new ::std::string;

  3408   }

  3409   file_basename_->assign(value);

  3410 }

  3411 inline void ClientDownloadRequest::set_file_basename(const char* value, size_t size) {

  3412   set_has_file_basename();

  3413   if (file_basename_ == &::google::protobuf::internal::kEmptyString) {

  3414     file_basename_ = new ::std::string;

  3415   }

  3416   file_basename_->assign(reinterpret_cast<const char*>(value), size);

  3417 }

  3418 inline ::std::string* ClientDownloadRequest::mutable_file_basename() {

  3419   set_has_file_basename();

  3420   if (file_basename_ == &::google::protobuf::internal::kEmptyString) {

  3421     file_basename_ = new ::std::string;

  3422   }

  3423   return file_basename_;

  3424 }

  3425 inline ::std::string* ClientDownloadRequest::release_file_basename() {

  3426   clear_has_file_basename();

  3427   if (file_basename_ == &::google::protobuf::internal::kEmptyString) {

  3428     return NULL;

  3429   } else {

  3430     ::std::string* temp = file_basename_;

  3431     file_basename_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  3432     return temp;

  3433   }

  3434 }

  3436 // optional .safe_browsing.ClientDownloadRequest.DownloadType download_type = 10 [default = WIN_EXECUTABLE];

  3437 inline bool ClientDownloadRequest::has_download_type() const {

  3438   return (_has_bits_[0] & 0x00000080u) != 0;

  3439 }

  3440 inline void ClientDownloadRequest::set_has_download_type() {

  3441   _has_bits_[0] |= 0x00000080u;

  3442 }

  3443 inline void ClientDownloadRequest::clear_has_download_type() {

  3444   _has_bits_[0] &= ~0x00000080u;

  3445 }

  3446 inline void ClientDownloadRequest::clear_download_type() {

  3447   download_type_ = 0;

  3448   clear_has_download_type();

  3449 }

  3450 inline ::safe_browsing::ClientDownloadRequest_DownloadType ClientDownloadRequest::download_type() const {

  3451   return static_cast< ::safe_browsing::ClientDownloadRequest_DownloadType >(download_type_);

  3452 }

  3453 inline void ClientDownloadRequest::set_download_type(::safe_browsing::ClientDownloadRequest_DownloadType value) {

  3454   GOOGLE_DCHECK(::safe_browsing::ClientDownloadRequest_DownloadType_IsValid(value));

  3455   set_has_download_type();

  3456   download_type_ = value;

  3457 }

  3459 // optional string locale = 11;

  3460 inline bool ClientDownloadRequest::has_locale() const {

  3461   return (_has_bits_[0] & 0x00000100u) != 0;

  3462 }

  3463 inline void ClientDownloadRequest::set_has_locale() {

  3464   _has_bits_[0] |= 0x00000100u;

  3465 }

  3466 inline void ClientDownloadRequest::clear_has_locale() {

  3467   _has_bits_[0] &= ~0x00000100u;

  3468 }

  3469 inline void ClientDownloadRequest::clear_locale() {

  3470   if (locale_ != &::google::protobuf::internal::kEmptyString) {

  3471     locale_->clear();

  3472   }

  3473   clear_has_locale();

  3474 }

  3475 inline const ::std::string& ClientDownloadRequest::locale() const {

  3476   return *locale_;

  3477 }

  3478 inline void ClientDownloadRequest::set_locale(const ::std::string& value) {

  3479   set_has_locale();

  3480   if (locale_ == &::google::protobuf::internal::kEmptyString) {

  3481     locale_ = new ::std::string;

  3482   }

  3483   locale_->assign(value);

  3484 }

  3485 inline void ClientDownloadRequest::set_locale(const char* value) {

  3486   set_has_locale();

  3487   if (locale_ == &::google::protobuf::internal::kEmptyString) {

  3488     locale_ = new ::std::string;

  3489   }

  3490   locale_->assign(value);

  3491 }

  3492 inline void ClientDownloadRequest::set_locale(const char* value, size_t size) {

  3493   set_has_locale();

  3494   if (locale_ == &::google::protobuf::internal::kEmptyString) {

  3495     locale_ = new ::std::string;

  3496   }

  3497   locale_->assign(reinterpret_cast<const char*>(value), size);

  3498 }

  3499 inline ::std::string* ClientDownloadRequest::mutable_locale() {

  3500   set_has_locale();

  3501   if (locale_ == &::google::protobuf::internal::kEmptyString) {

  3502     locale_ = new ::std::string;

  3503   }

  3504   return locale_;

  3505 }

  3506 inline ::std::string* ClientDownloadRequest::release_locale() {

  3507   clear_has_locale();

  3508   if (locale_ == &::google::protobuf::internal::kEmptyString) {

  3509     return NULL;

  3510   } else {

  3511     ::std::string* temp = locale_;

  3512     locale_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  3513     return temp;

  3514   }

  3515 }

  3517 // -------------------------------------------------------------------

  3519 // ClientDownloadResponse_MoreInfo

  3521 // optional string description = 1;

  3522 inline bool ClientDownloadResponse_MoreInfo::has_description() const {

  3523   return (_has_bits_[0] & 0x00000001u) != 0;

  3524 }

  3525 inline void ClientDownloadResponse_MoreInfo::set_has_description() {

  3526   _has_bits_[0] |= 0x00000001u;

  3527 }

  3528 inline void ClientDownloadResponse_MoreInfo::clear_has_description() {

  3529   _has_bits_[0] &= ~0x00000001u;

  3530 }

  3531 inline void ClientDownloadResponse_MoreInfo::clear_description() {

  3532   if (description_ != &::google::protobuf::internal::kEmptyString) {

  3533     description_->clear();

  3534   }

  3535   clear_has_description();

  3536 }

  3537 inline const ::std::string& ClientDownloadResponse_MoreInfo::description() const {

  3538   return *description_;

  3539 }

  3540 inline void ClientDownloadResponse_MoreInfo::set_description(const ::std::string& value) {

  3541   set_has_description();

  3542   if (description_ == &::google::protobuf::internal::kEmptyString) {

  3543     description_ = new ::std::string;

  3544   }

  3545   description_->assign(value);

  3546 }

  3547 inline void ClientDownloadResponse_MoreInfo::set_description(const char* value) {

  3548   set_has_description();

  3549   if (description_ == &::google::protobuf::internal::kEmptyString) {

  3550     description_ = new ::std::string;

  3551   }

  3552   description_->assign(value);

  3553 }

  3554 inline void ClientDownloadResponse_MoreInfo::set_description(const char* value, size_t size) {

  3555   set_has_description();

  3556   if (description_ == &::google::protobuf::internal::kEmptyString) {

  3557     description_ = new ::std::string;

  3558   }

  3559   description_->assign(reinterpret_cast<const char*>(value), size);

  3560 }

  3561 inline ::std::string* ClientDownloadResponse_MoreInfo::mutable_description() {

  3562   set_has_description();

  3563   if (description_ == &::google::protobuf::internal::kEmptyString) {

  3564     description_ = new ::std::string;

  3565   }

  3566   return description_;

  3567 }

  3568 inline ::std::string* ClientDownloadResponse_MoreInfo::release_description() {

  3569   clear_has_description();

  3570   if (description_ == &::google::protobuf::internal::kEmptyString) {

  3571     return NULL;

  3572   } else {

  3573     ::std::string* temp = description_;

  3574     description_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  3575     return temp;

  3576   }

  3577 }

  3579 // optional string url = 2;

  3580 inline bool ClientDownloadResponse_MoreInfo::has_url() const {

  3581   return (_has_bits_[0] & 0x00000002u) != 0;

  3582 }

  3583 inline void ClientDownloadResponse_MoreInfo::set_has_url() {

  3584   _has_bits_[0] |= 0x00000002u;

  3585 }

  3586 inline void ClientDownloadResponse_MoreInfo::clear_has_url() {

  3587   _has_bits_[0] &= ~0x00000002u;

  3588 }

  3589 inline void ClientDownloadResponse_MoreInfo::clear_url() {

  3590   if (url_ != &::google::protobuf::internal::kEmptyString) {

  3591     url_->clear();

  3592   }

  3593   clear_has_url();

  3594 }

  3595 inline const ::std::string& ClientDownloadResponse_MoreInfo::url() const {

  3596   return *url_;

  3597 }

  3598 inline void ClientDownloadResponse_MoreInfo::set_url(const ::std::string& value) {

  3599   set_has_url();

  3600   if (url_ == &::google::protobuf::internal::kEmptyString) {

  3601     url_ = new ::std::string;

  3602   }

  3603   url_->assign(value);

  3604 }

  3605 inline void ClientDownloadResponse_MoreInfo::set_url(const char* value) {

  3606   set_has_url();

  3607   if (url_ == &::google::protobuf::internal::kEmptyString) {

  3608     url_ = new ::std::string;

  3609   }

  3610   url_->assign(value);

  3611 }

  3612 inline void ClientDownloadResponse_MoreInfo::set_url(const char* value, size_t size) {

  3613   set_has_url();

  3614   if (url_ == &::google::protobuf::internal::kEmptyString) {

  3615     url_ = new ::std::string;

  3616   }

  3617   url_->assign(reinterpret_cast<const char*>(value), size);

  3618 }

  3619 inline ::std::string* ClientDownloadResponse_MoreInfo::mutable_url() {

  3620   set_has_url();

  3621   if (url_ == &::google::protobuf::internal::kEmptyString) {

  3622     url_ = new ::std::string;

  3623   }

  3624   return url_;

  3625 }

  3626 inline ::std::string* ClientDownloadResponse_MoreInfo::release_url() {

  3627   clear_has_url();

  3628   if (url_ == &::google::protobuf::internal::kEmptyString) {

  3629     return NULL;

  3630   } else {

  3631     ::std::string* temp = url_;

  3632     url_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  3633     return temp;

  3634   }

  3635 }

  3637 // -------------------------------------------------------------------

  3639 // ClientDownloadResponse

  3641 // required .safe_browsing.ClientDownloadResponse.Verdict verdict = 1;

  3642 inline bool ClientDownloadResponse::has_verdict() const {

  3643   return (_has_bits_[0] & 0x00000001u) != 0;

  3644 }

  3645 inline void ClientDownloadResponse::set_has_verdict() {

  3646   _has_bits_[0] |= 0x00000001u;

  3647 }

  3648 inline void ClientDownloadResponse::clear_has_verdict() {

  3649   _has_bits_[0] &= ~0x00000001u;

  3650 }

  3651 inline void ClientDownloadResponse::clear_verdict() {

  3652   verdict_ = 0;

  3653   clear_has_verdict();

  3654 }

  3655 inline ::safe_browsing::ClientDownloadResponse_Verdict ClientDownloadResponse::verdict() const {

  3656   return static_cast< ::safe_browsing::ClientDownloadResponse_Verdict >(verdict_);

  3657 }

  3658 inline void ClientDownloadResponse::set_verdict(::safe_browsing::ClientDownloadResponse_Verdict value) {

  3659   GOOGLE_DCHECK(::safe_browsing::ClientDownloadResponse_Verdict_IsValid(value));

  3660   set_has_verdict();

  3661   verdict_ = value;

  3662 }

  3664 // optional .safe_browsing.ClientDownloadResponse.MoreInfo more_info = 2;

  3665 inline bool ClientDownloadResponse::has_more_info() const {

  3666   return (_has_bits_[0] & 0x00000002u) != 0;

  3667 }

  3668 inline void ClientDownloadResponse::set_has_more_info() {

  3669   _has_bits_[0] |= 0x00000002u;

  3670 }

  3671 inline void ClientDownloadResponse::clear_has_more_info() {

  3672   _has_bits_[0] &= ~0x00000002u;

  3673 }

  3674 inline void ClientDownloadResponse::clear_more_info() {

  3675   if (more_info_ != NULL) more_info_->::safe_browsing::ClientDownloadResponse_MoreInfo::Clear();

  3676   clear_has_more_info();

  3677 }

  3678 inline const ::safe_browsing::ClientDownloadResponse_MoreInfo& ClientDownloadResponse::more_info() const {

  3679   return more_info_ != NULL ? *more_info_ : *default_instance_->more_info_;

  3680 }

  3681 inline ::safe_browsing::ClientDownloadResponse_MoreInfo* ClientDownloadResponse::mutable_more_info() {

  3682   set_has_more_info();

  3683   if (more_info_ == NULL) more_info_ = new ::safe_browsing::ClientDownloadResponse_MoreInfo;

  3684   return more_info_;

  3685 }

  3686 inline ::safe_browsing::ClientDownloadResponse_MoreInfo* ClientDownloadResponse::release_more_info() {

  3687   clear_has_more_info();

  3688   ::safe_browsing::ClientDownloadResponse_MoreInfo* temp = more_info_;

  3689   more_info_ = NULL;

  3690   return temp;

  3691 }

  3693 // optional bytes token = 3;

  3694 inline bool ClientDownloadResponse::has_token() const {

  3695   return (_has_bits_[0] & 0x00000004u) != 0;

  3696 }

  3697 inline void ClientDownloadResponse::set_has_token() {

  3698   _has_bits_[0] |= 0x00000004u;

  3699 }

  3700 inline void ClientDownloadResponse::clear_has_token() {

  3701   _has_bits_[0] &= ~0x00000004u;

  3702 }

  3703 inline void ClientDownloadResponse::clear_token() {

  3704   if (token_ != &::google::protobuf::internal::kEmptyString) {

  3705     token_->clear();

  3706   }

  3707   clear_has_token();

  3708 }

  3709 inline const ::std::string& ClientDownloadResponse::token() const {

  3710   return *token_;

  3711 }

  3712 inline void ClientDownloadResponse::set_token(const ::std::string& value) {

  3713   set_has_token();

  3714   if (token_ == &::google::protobuf::internal::kEmptyString) {

  3715     token_ = new ::std::string;

  3716   }

  3717   token_->assign(value);

  3718 }

  3719 inline void ClientDownloadResponse::set_token(const char* value) {

  3720   set_has_token();

  3721   if (token_ == &::google::protobuf::internal::kEmptyString) {

  3722     token_ = new ::std::string;

  3723   }

  3724   token_->assign(value);

  3725 }

  3726 inline void ClientDownloadResponse::set_token(const void* value, size_t size) {

  3727   set_has_token();

  3728   if (token_ == &::google::protobuf::internal::kEmptyString) {

  3729     token_ = new ::std::string;

  3730   }

  3731   token_->assign(reinterpret_cast<const char*>(value), size);

  3732 }

  3733 inline ::std::string* ClientDownloadResponse::mutable_token() {

  3734   set_has_token();

  3735   if (token_ == &::google::protobuf::internal::kEmptyString) {

  3736     token_ = new ::std::string;

  3737   }

  3738   return token_;

  3739 }

  3740 inline ::std::string* ClientDownloadResponse::release_token() {

  3741   clear_has_token();

  3742   if (token_ == &::google::protobuf::internal::kEmptyString) {

  3743     return NULL;

  3744   } else {

  3745     ::std::string* temp = token_;

  3746     token_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  3747     return temp;

  3748   }

  3749 }

  3751 // -------------------------------------------------------------------

  3753 // ClientDownloadReport_UserInformation

  3755 // optional string email = 1;

  3756 inline bool ClientDownloadReport_UserInformation::has_email() const {

  3757   return (_has_bits_[0] & 0x00000001u) != 0;

  3758 }

  3759 inline void ClientDownloadReport_UserInformation::set_has_email() {

  3760   _has_bits_[0] |= 0x00000001u;

  3761 }

  3762 inline void ClientDownloadReport_UserInformation::clear_has_email() {

  3763   _has_bits_[0] &= ~0x00000001u;

  3764 }

  3765 inline void ClientDownloadReport_UserInformation::clear_email() {

  3766   if (email_ != &::google::protobuf::internal::kEmptyString) {

  3767     email_->clear();

  3768   }

  3769   clear_has_email();

  3770 }

  3771 inline const ::std::string& ClientDownloadReport_UserInformation::email() const {

  3772   return *email_;

  3773 }

  3774 inline void ClientDownloadReport_UserInformation::set_email(const ::std::string& value) {

  3775   set_has_email();

  3776   if (email_ == &::google::protobuf::internal::kEmptyString) {

  3777     email_ = new ::std::string;

  3778   }

  3779   email_->assign(value);

  3780 }

  3781 inline void ClientDownloadReport_UserInformation::set_email(const char* value) {

  3782   set_has_email();

  3783   if (email_ == &::google::protobuf::internal::kEmptyString) {

  3784     email_ = new ::std::string;

  3785   }

  3786   email_->assign(value);

  3787 }

  3788 inline void ClientDownloadReport_UserInformation::set_email(const char* value, size_t size) {

  3789   set_has_email();

  3790   if (email_ == &::google::protobuf::internal::kEmptyString) {

  3791     email_ = new ::std::string;

  3792   }

  3793   email_->assign(reinterpret_cast<const char*>(value), size);

  3794 }

  3795 inline ::std::string* ClientDownloadReport_UserInformation::mutable_email() {

  3796   set_has_email();

  3797   if (email_ == &::google::protobuf::internal::kEmptyString) {

  3798     email_ = new ::std::string;

  3799   }

  3800   return email_;

  3801 }

  3802 inline ::std::string* ClientDownloadReport_UserInformation::release_email() {

  3803   clear_has_email();

  3804   if (email_ == &::google::protobuf::internal::kEmptyString) {

  3805     return NULL;

  3806   } else {

  3807     ::std::string* temp = email_;

  3808     email_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  3809     return temp;

  3810   }

  3811 }

  3813 // -------------------------------------------------------------------

  3815 // ClientDownloadReport

  3817 // optional .safe_browsing.ClientDownloadReport.Reason reason = 1;

  3818 inline bool ClientDownloadReport::has_reason() const {

  3819   return (_has_bits_[0] & 0x00000001u) != 0;

  3820 }

  3821 inline void ClientDownloadReport::set_has_reason() {

  3822   _has_bits_[0] |= 0x00000001u;

  3823 }

  3824 inline void ClientDownloadReport::clear_has_reason() {

  3825   _has_bits_[0] &= ~0x00000001u;

  3826 }

  3827 inline void ClientDownloadReport::clear_reason() {

  3828   reason_ = 0;

  3829   clear_has_reason();

  3830 }

  3831 inline ::safe_browsing::ClientDownloadReport_Reason ClientDownloadReport::reason() const {

  3832   return static_cast< ::safe_browsing::ClientDownloadReport_Reason >(reason_);

  3833 }

  3834 inline void ClientDownloadReport::set_reason(::safe_browsing::ClientDownloadReport_Reason value) {

  3835   GOOGLE_DCHECK(::safe_browsing::ClientDownloadReport_Reason_IsValid(value));

  3836   set_has_reason();

  3837   reason_ = value;

  3838 }

  3840 // optional .safe_browsing.ClientDownloadRequest download_request = 2;

  3841 inline bool ClientDownloadReport::has_download_request() const {

  3842   return (_has_bits_[0] & 0x00000002u) != 0;

  3843 }

  3844 inline void ClientDownloadReport::set_has_download_request() {

  3845   _has_bits_[0] |= 0x00000002u;

  3846 }

  3847 inline void ClientDownloadReport::clear_has_download_request() {

  3848   _has_bits_[0] &= ~0x00000002u;

  3849 }

  3850 inline void ClientDownloadReport::clear_download_request() {

  3851   if (download_request_ != NULL) download_request_->::safe_browsing::ClientDownloadRequest::Clear();

  3852   clear_has_download_request();

  3853 }

  3854 inline const ::safe_browsing::ClientDownloadRequest& ClientDownloadReport::download_request() const {

  3855   return download_request_ != NULL ? *download_request_ : *default_instance_->download_request_;

  3856 }

  3857 inline ::safe_browsing::ClientDownloadRequest* ClientDownloadReport::mutable_download_request() {

  3858   set_has_download_request();

  3859   if (download_request_ == NULL) download_request_ = new ::safe_browsing::ClientDownloadRequest;

  3860   return download_request_;

  3861 }

  3862 inline ::safe_browsing::ClientDownloadRequest* ClientDownloadReport::release_download_request() {

  3863   clear_has_download_request();

  3864   ::safe_browsing::ClientDownloadRequest* temp = download_request_;

  3865   download_request_ = NULL;

  3866   return temp;

  3867 }

  3869 // optional .safe_browsing.ClientDownloadReport.UserInformation user_information = 3;

  3870 inline bool ClientDownloadReport::has_user_information() const {

  3871   return (_has_bits_[0] & 0x00000004u) != 0;

  3872 }

  3873 inline void ClientDownloadReport::set_has_user_information() {

  3874   _has_bits_[0] |= 0x00000004u;

  3875 }

  3876 inline void ClientDownloadReport::clear_has_user_information() {

  3877   _has_bits_[0] &= ~0x00000004u;

  3878 }

  3879 inline void ClientDownloadReport::clear_user_information() {

  3880   if (user_information_ != NULL) user_information_->::safe_browsing::ClientDownloadReport_UserInformation::Clear();

  3881   clear_has_user_information();

  3882 }

  3883 inline const ::safe_browsing::ClientDownloadReport_UserInformation& ClientDownloadReport::user_information() const {

  3884   return user_information_ != NULL ? *user_information_ : *default_instance_->user_information_;

  3885 }

  3886 inline ::safe_browsing::ClientDownloadReport_UserInformation* ClientDownloadReport::mutable_user_information() {

  3887   set_has_user_information();

  3888   if (user_information_ == NULL) user_information_ = new ::safe_browsing::ClientDownloadReport_UserInformation;

  3889   return user_information_;

  3890 }

  3891 inline ::safe_browsing::ClientDownloadReport_UserInformation* ClientDownloadReport::release_user_information() {

  3892   clear_has_user_information();

  3893   ::safe_browsing::ClientDownloadReport_UserInformation* temp = user_information_;

  3894   user_information_ = NULL;

  3895   return temp;

  3896 }

  3898 // optional bytes comment = 4;

  3899 inline bool ClientDownloadReport::has_comment() const {

  3900   return (_has_bits_[0] & 0x00000008u) != 0;

  3901 }

  3902 inline void ClientDownloadReport::set_has_comment() {

  3903   _has_bits_[0] |= 0x00000008u;

  3904 }

  3905 inline void ClientDownloadReport::clear_has_comment() {

  3906   _has_bits_[0] &= ~0x00000008u;

  3907 }

  3908 inline void ClientDownloadReport::clear_comment() {

  3909   if (comment_ != &::google::protobuf::internal::kEmptyString) {

  3910     comment_->clear();

  3911   }

  3912   clear_has_comment();

  3913 }

  3914 inline const ::std::string& ClientDownloadReport::comment() const {

  3915   return *comment_;

  3916 }

  3917 inline void ClientDownloadReport::set_comment(const ::std::string& value) {

  3918   set_has_comment();

  3919   if (comment_ == &::google::protobuf::internal::kEmptyString) {

  3920     comment_ = new ::std::string;

  3921   }

  3922   comment_->assign(value);

  3923 }

  3924 inline void ClientDownloadReport::set_comment(const char* value) {

  3925   set_has_comment();

  3926   if (comment_ == &::google::protobuf::internal::kEmptyString) {

  3927     comment_ = new ::std::string;

  3928   }

  3929   comment_->assign(value);

  3930 }

  3931 inline void ClientDownloadReport::set_comment(const void* value, size_t size) {

  3932   set_has_comment();

  3933   if (comment_ == &::google::protobuf::internal::kEmptyString) {

  3934     comment_ = new ::std::string;

  3935   }

  3936   comment_->assign(reinterpret_cast<const char*>(value), size);

  3937 }

  3938 inline ::std::string* ClientDownloadReport::mutable_comment() {

  3939   set_has_comment();

  3940   if (comment_ == &::google::protobuf::internal::kEmptyString) {

  3941     comment_ = new ::std::string;

  3942   }

  3943   return comment_;

  3944 }

  3945 inline ::std::string* ClientDownloadReport::release_comment() {

  3946   clear_has_comment();

  3947   if (comment_ == &::google::protobuf::internal::kEmptyString) {

  3948     return NULL;

  3949   } else {

  3950     ::std::string* temp = comment_;

  3951     comment_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  3952     return temp;

  3953   }

  3954 }

  3956 // optional .safe_browsing.ClientDownloadResponse download_response = 5;

  3957 inline bool ClientDownloadReport::has_download_response() const {

  3958   return (_has_bits_[0] & 0x00000010u) != 0;

  3959 }

  3960 inline void ClientDownloadReport::set_has_download_response() {

  3961   _has_bits_[0] |= 0x00000010u;

  3962 }

  3963 inline void ClientDownloadReport::clear_has_download_response() {

  3964   _has_bits_[0] &= ~0x00000010u;

  3965 }

  3966 inline void ClientDownloadReport::clear_download_response() {

  3967   if (download_response_ != NULL) download_response_->::safe_browsing::ClientDownloadResponse::Clear();

  3968   clear_has_download_response();

  3969 }

  3970 inline const ::safe_browsing::ClientDownloadResponse& ClientDownloadReport::download_response() const {

  3971   return download_response_ != NULL ? *download_response_ : *default_instance_->download_response_;

  3972 }

  3973 inline ::safe_browsing::ClientDownloadResponse* ClientDownloadReport::mutable_download_response() {

  3974   set_has_download_response();

  3975   if (download_response_ == NULL) download_response_ = new ::safe_browsing::ClientDownloadResponse;

  3976   return download_response_;

  3977 }

  3978 inline ::safe_browsing::ClientDownloadResponse* ClientDownloadReport::release_download_response() {

  3979   clear_has_download_response();

  3980   ::safe_browsing::ClientDownloadResponse* temp = download_response_;

  3981   download_response_ = NULL;

  3982   return temp;

  3983 }

  3985 // -------------------------------------------------------------------

  3987 // ClientUploadResponse

  3989 // optional .safe_browsing.ClientUploadResponse.UploadStatus status = 1;

  3990 inline bool ClientUploadResponse::has_status() const {

  3991   return (_has_bits_[0] & 0x00000001u) != 0;

  3992 }

  3993 inline void ClientUploadResponse::set_has_status() {

  3994   _has_bits_[0] |= 0x00000001u;

  3995 }

  3996 inline void ClientUploadResponse::clear_has_status() {

  3997   _has_bits_[0] &= ~0x00000001u;

  3998 }

  3999 inline void ClientUploadResponse::clear_status() {

  4000   status_ = 0;

  4001   clear_has_status();

  4002 }

  4003 inline ::safe_browsing::ClientUploadResponse_UploadStatus ClientUploadResponse::status() const {

  4004   return static_cast< ::safe_browsing::ClientUploadResponse_UploadStatus >(status_);

  4005 }

  4006 inline void ClientUploadResponse::set_status(::safe_browsing::ClientUploadResponse_UploadStatus value) {

  4007   GOOGLE_DCHECK(::safe_browsing::ClientUploadResponse_UploadStatus_IsValid(value));

  4008   set_has_status();

  4009   status_ = value;

  4010 }

  4012 // optional string permalink = 2;

  4013 inline bool ClientUploadResponse::has_permalink() const {

  4014   return (_has_bits_[0] & 0x00000002u) != 0;

  4015 }

  4016 inline void ClientUploadResponse::set_has_permalink() {

  4017   _has_bits_[0] |= 0x00000002u;

  4018 }

  4019 inline void ClientUploadResponse::clear_has_permalink() {

  4020   _has_bits_[0] &= ~0x00000002u;

  4021 }

  4022 inline void ClientUploadResponse::clear_permalink() {

  4023   if (permalink_ != &::google::protobuf::internal::kEmptyString) {

  4024     permalink_->clear();

  4025   }

  4026   clear_has_permalink();

  4027 }

  4028 inline const ::std::string& ClientUploadResponse::permalink() const {

  4029   return *permalink_;

  4030 }

  4031 inline void ClientUploadResponse::set_permalink(const ::std::string& value) {

  4032   set_has_permalink();

  4033   if (permalink_ == &::google::protobuf::internal::kEmptyString) {

  4034     permalink_ = new ::std::string;

  4035   }

  4036   permalink_->assign(value);

  4037 }

  4038 inline void ClientUploadResponse::set_permalink(const char* value) {

  4039   set_has_permalink();

  4040   if (permalink_ == &::google::protobuf::internal::kEmptyString) {

  4041     permalink_ = new ::std::string;

  4042   }

  4043   permalink_->assign(value);

  4044 }

  4045 inline void ClientUploadResponse::set_permalink(const char* value, size_t size) {

  4046   set_has_permalink();

  4047   if (permalink_ == &::google::protobuf::internal::kEmptyString) {

  4048     permalink_ = new ::std::string;

  4049   }

  4050   permalink_->assign(reinterpret_cast<const char*>(value), size);

  4051 }

  4052 inline ::std::string* ClientUploadResponse::mutable_permalink() {

  4053   set_has_permalink();

  4054   if (permalink_ == &::google::protobuf::internal::kEmptyString) {

  4055     permalink_ = new ::std::string;

  4056   }

  4057   return permalink_;

  4058 }

  4059 inline ::std::string* ClientUploadResponse::release_permalink() {

  4060   clear_has_permalink();

  4061   if (permalink_ == &::google::protobuf::internal::kEmptyString) {

  4062     return NULL;

  4063   } else {

  4064     ::std::string* temp = permalink_;

  4065     permalink_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);

  4066     return temp;

  4067   }

  4068 }

  4071 // @@protoc_insertion_point(namespace_scope)

  4073 }  // namespace safe_browsing

  4075 // @@protoc_insertion_point(global_scope)

  4077 #endif  // PROTOBUF_csd_2eproto__INCLUDED

The Tor Browser / file revision

toolkit/components/downloads/csd.pb.h@925c144e1f1f

toolkit/components/downloads/csd.pb.h