The Tor Browser / file comparison

comparison: toolkit/components/downloads/csd.pb.h

toolkit/components/downloads/csd.pb.h

branch
TOR_BUG_9701
changeset 14
925c144e1f1f
equal deleted inserted replaced
-1:000000000000 0:67385f192706
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: csd.proto
3
4 #ifndef PROTOBUF_csd_2eproto__INCLUDED
5 #define PROTOBUF_csd_2eproto__INCLUDED
6
7 #include <string>
8
9 #include <google/protobuf/stubs/common.h>
10
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
21
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)
26
27 namespace safe_browsing {
28
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();
33
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;
51
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;
62
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;
73
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;
85
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;
95
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;
104
105 // ===================================================================
106
107 class ClientPhishingRequest_Feature : public ::google::protobuf::MessageLite {
108 public:
109 ClientPhishingRequest_Feature();
110 virtual ~ClientPhishingRequest_Feature();
111
112 ClientPhishingRequest_Feature(const ClientPhishingRequest_Feature& from);
113
114 inline ClientPhishingRequest_Feature& operator=(const ClientPhishingRequest_Feature& from) {
115 CopyFrom(from);
116 return *this;
117 }
118
119 static const ClientPhishingRequest_Feature& default_instance();
120
121 void Swap(ClientPhishingRequest_Feature* other);
122
123 // implements Message ----------------------------------------------
124
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;
131
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:
143
144 ::std::string GetTypeName() const;
145
146 // nested types ----------------------------------------------------
147
148 // accessors -------------------------------------------------------
149
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();
160
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);
167
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();
174
175 ::std::string* name_;
176 double value_;
177
178 mutable int _cached_size_;
179 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
180
181 friend void protobuf_AddDesc_csd_2eproto();
182 friend void protobuf_AssignDesc_csd_2eproto();
183 friend void protobuf_ShutdownFile_csd_2eproto();
184
185 void InitAsDefaultInstance();
186 static ClientPhishingRequest_Feature* default_instance_;
187 };
188 // -------------------------------------------------------------------
189
190 class ClientPhishingRequest : public ::google::protobuf::MessageLite {
191 public:
192 ClientPhishingRequest();
193 virtual ~ClientPhishingRequest();
194
195 ClientPhishingRequest(const ClientPhishingRequest& from);
196
197 inline ClientPhishingRequest& operator=(const ClientPhishingRequest& from) {
198 CopyFrom(from);
199 return *this;
200 }
201
202 static const ClientPhishingRequest& default_instance();
203
204 void Swap(ClientPhishingRequest* other);
205
206 // implements Message ----------------------------------------------
207
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;
214
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:
226
227 ::std::string GetTypeName() const;
228
229 // nested types ----------------------------------------------------
230
231 typedef ClientPhishingRequest_Feature Feature;
232
233 // accessors -------------------------------------------------------
234
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();
245
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();
256
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);
263
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);
270
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();
282
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);
289
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();
301
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();
312
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();
327
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_;
336
337 mutable int _cached_size_;
338 ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
339
340 friend void protobuf_AddDesc_csd_2eproto();
341 friend void protobuf_AssignDesc_csd_2eproto();
342 friend void protobuf_ShutdownFile_csd_2eproto();
343
344 void InitAsDefaultInstance();
345 static ClientPhishingRequest* default_instance_;
346 };
347 // -------------------------------------------------------------------
348
349 class ClientPhishingResponse : public ::google::protobuf::MessageLite {
350 public:
351 ClientPhishingResponse();
352 virtual ~ClientPhishingResponse();
353
354 ClientPhishingResponse(const ClientPhishingResponse& from);
355
356 inline ClientPhishingResponse& operator=(const ClientPhishingResponse& from) {
357 CopyFrom(from);
358 return *this;
359 }
360
361 static const ClientPhishingResponse& default_instance();
362
363 void Swap(ClientPhishingResponse* other);
364
365 // implements Message ----------------------------------------------
366
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;
373
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:
385
386 ::std::string GetTypeName() const;
387
388 // nested types ----------------------------------------------------
389
390 // accessors -------------------------------------------------------
391
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);
398
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();
414
415 // @@protoc_insertion_point(class_scope:safe_browsing.ClientPhishingResponse)
416 private:
417 inline void set_has_phishy();
418 inline void clear_has_phishy();
419
420 ::google::protobuf::RepeatedPtrField< ::std::string> obsolete_whitelist_expression_;
421 bool phishy_;
422
423 mutable int _cached_size_;
424 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
425
426 friend void protobuf_AddDesc_csd_2eproto();
427 friend void protobuf_AssignDesc_csd_2eproto();
428 friend void protobuf_ShutdownFile_csd_2eproto();
429
430 void InitAsDefaultInstance();
431 static ClientPhishingResponse* default_instance_;
432 };
433 // -------------------------------------------------------------------
434
435 class ClientMalwareRequest_Feature : public ::google::protobuf::MessageLite {
436 public:
437 ClientMalwareRequest_Feature();
438 virtual ~ClientMalwareRequest_Feature();
439
440 ClientMalwareRequest_Feature(const ClientMalwareRequest_Feature& from);
441
442 inline ClientMalwareRequest_Feature& operator=(const ClientMalwareRequest_Feature& from) {
443 CopyFrom(from);
444 return *this;
445 }
446
447 static const ClientMalwareRequest_Feature& default_instance();
448
449 void Swap(ClientMalwareRequest_Feature* other);
450
451 // implements Message ----------------------------------------------
452
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;
459
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:
471
472 ::std::string GetTypeName() const;
473
474 // nested types ----------------------------------------------------
475
476 // accessors -------------------------------------------------------
477
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();
488
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);
495
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();
511
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();
518
519 ::std::string* name_;
520 double value_;
521 ::google::protobuf::RepeatedPtrField< ::std::string> metainfo_;
522
523 mutable int _cached_size_;
524 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
525
526 friend void protobuf_AddDesc_csd_2eproto();
527 friend void protobuf_AssignDesc_csd_2eproto();
528 friend void protobuf_ShutdownFile_csd_2eproto();
529
530 void InitAsDefaultInstance();
531 static ClientMalwareRequest_Feature* default_instance_;
532 };
533 // -------------------------------------------------------------------
534
535 class ClientMalwareRequest : public ::google::protobuf::MessageLite {
536 public:
537 ClientMalwareRequest();
538 virtual ~ClientMalwareRequest();
539
540 ClientMalwareRequest(const ClientMalwareRequest& from);
541
542 inline ClientMalwareRequest& operator=(const ClientMalwareRequest& from) {
543 CopyFrom(from);
544 return *this;
545 }
546
547 static const ClientMalwareRequest& default_instance();
548
549 void Swap(ClientMalwareRequest* other);
550
551 // implements Message ----------------------------------------------
552
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;
559
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:
571
572 ::std::string GetTypeName() const;
573
574 // nested types ----------------------------------------------------
575
576 typedef ClientMalwareRequest_Feature Feature;
577
578 // accessors -------------------------------------------------------
579
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();
590
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();
602
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();
613
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();
620
621 ::std::string* url_;
622 ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientMalwareRequest_Feature > feature_map_;
623 ::std::string* referrer_url_;
624
625 mutable int _cached_size_;
626 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
627
628 friend void protobuf_AddDesc_csd_2eproto();
629 friend void protobuf_AssignDesc_csd_2eproto();
630 friend void protobuf_ShutdownFile_csd_2eproto();
631
632 void InitAsDefaultInstance();
633 static ClientMalwareRequest* default_instance_;
634 };
635 // -------------------------------------------------------------------
636
637 class ClientMalwareResponse : public ::google::protobuf::MessageLite {
638 public:
639 ClientMalwareResponse();
640 virtual ~ClientMalwareResponse();
641
642 ClientMalwareResponse(const ClientMalwareResponse& from);
643
644 inline ClientMalwareResponse& operator=(const ClientMalwareResponse& from) {
645 CopyFrom(from);
646 return *this;
647 }
648
649 static const ClientMalwareResponse& default_instance();
650
651 void Swap(ClientMalwareResponse* other);
652
653 // implements Message ----------------------------------------------
654
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;
661
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:
673
674 ::std::string GetTypeName() const;
675
676 // nested types ----------------------------------------------------
677
678 // accessors -------------------------------------------------------
679
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);
686
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();
697
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();
704
705 ::std::string* bad_ip_;
706 bool blacklist_;
707
708 mutable int _cached_size_;
709 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
710
711 friend void protobuf_AddDesc_csd_2eproto();
712 friend void protobuf_AssignDesc_csd_2eproto();
713 friend void protobuf_ShutdownFile_csd_2eproto();
714
715 void InitAsDefaultInstance();
716 static ClientMalwareResponse* default_instance_;
717 };
718 // -------------------------------------------------------------------
719
720 class ClientDownloadRequest_Digests : public ::google::protobuf::MessageLite {
721 public:
722 ClientDownloadRequest_Digests();
723 virtual ~ClientDownloadRequest_Digests();
724
725 ClientDownloadRequest_Digests(const ClientDownloadRequest_Digests& from);
726
727 inline ClientDownloadRequest_Digests& operator=(const ClientDownloadRequest_Digests& from) {
728 CopyFrom(from);
729 return *this;
730 }
731
732 static const ClientDownloadRequest_Digests& default_instance();
733
734 void Swap(ClientDownloadRequest_Digests* other);
735
736 // implements Message ----------------------------------------------
737
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;
744
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:
756
757 ::std::string GetTypeName() const;
758
759 // nested types ----------------------------------------------------
760
761 // accessors -------------------------------------------------------
762
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();
773
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();
784
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();
795
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();
804
805 ::std::string* sha256_;
806 ::std::string* sha1_;
807 ::std::string* md5_;
808
809 mutable int _cached_size_;
810 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
811
812 friend void protobuf_AddDesc_csd_2eproto();
813 friend void protobuf_AssignDesc_csd_2eproto();
814 friend void protobuf_ShutdownFile_csd_2eproto();
815
816 void InitAsDefaultInstance();
817 static ClientDownloadRequest_Digests* default_instance_;
818 };
819 // -------------------------------------------------------------------
820
821 class ClientDownloadRequest_Resource : public ::google::protobuf::MessageLite {
822 public:
823 ClientDownloadRequest_Resource();
824 virtual ~ClientDownloadRequest_Resource();
825
826 ClientDownloadRequest_Resource(const ClientDownloadRequest_Resource& from);
827
828 inline ClientDownloadRequest_Resource& operator=(const ClientDownloadRequest_Resource& from) {
829 CopyFrom(from);
830 return *this;
831 }
832
833 static const ClientDownloadRequest_Resource& default_instance();
834
835 void Swap(ClientDownloadRequest_Resource* other);
836
837 // implements Message ----------------------------------------------
838
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;
845
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:
857
858 ::std::string GetTypeName() const;
859
860 // nested types ----------------------------------------------------
861
862 // accessors -------------------------------------------------------
863
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();
874
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);
881
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();
892
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();
903
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();
914
915 ::std::string* url_;
916 ::std::string* remote_ip_;
917 ::std::string* referrer_;
918 int type_;
919
920 mutable int _cached_size_;
921 ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
922
923 friend void protobuf_AddDesc_csd_2eproto();
924 friend void protobuf_AssignDesc_csd_2eproto();
925 friend void protobuf_ShutdownFile_csd_2eproto();
926
927 void InitAsDefaultInstance();
928 static ClientDownloadRequest_Resource* default_instance_;
929 };
930 // -------------------------------------------------------------------
931
932 class ClientDownloadRequest_CertificateChain_Element : public ::google::protobuf::MessageLite {
933 public:
934 ClientDownloadRequest_CertificateChain_Element();
935 virtual ~ClientDownloadRequest_CertificateChain_Element();
936
937 ClientDownloadRequest_CertificateChain_Element(const ClientDownloadRequest_CertificateChain_Element& from);
938
939 inline ClientDownloadRequest_CertificateChain_Element& operator=(const ClientDownloadRequest_CertificateChain_Element& from) {
940 CopyFrom(from);
941 return *this;
942 }
943
944 static const ClientDownloadRequest_CertificateChain_Element& default_instance();
945
946 void Swap(ClientDownloadRequest_CertificateChain_Element* other);
947
948 // implements Message ----------------------------------------------
949
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;
956
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:
968
969 ::std::string GetTypeName() const;
970
971 // nested types ----------------------------------------------------
972
973 // accessors -------------------------------------------------------
974
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();
985
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();
990
991 ::std::string* certificate_;
992
993 mutable int _cached_size_;
994 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
995
996 friend void protobuf_AddDesc_csd_2eproto();
997 friend void protobuf_AssignDesc_csd_2eproto();
998 friend void protobuf_ShutdownFile_csd_2eproto();
999
1000 void InitAsDefaultInstance();
1001 static ClientDownloadRequest_CertificateChain_Element* default_instance_;
1002 };
1003 // -------------------------------------------------------------------
1004
1005 class ClientDownloadRequest_CertificateChain : public ::google::protobuf::MessageLite {
1006 public:
1007 ClientDownloadRequest_CertificateChain();
1008 virtual ~ClientDownloadRequest_CertificateChain();
1009
1010 ClientDownloadRequest_CertificateChain(const ClientDownloadRequest_CertificateChain& from);
1011
1012 inline ClientDownloadRequest_CertificateChain& operator=(const ClientDownloadRequest_CertificateChain& from) {
1013 CopyFrom(from);
1014 return *this;
1015 }
1016
1017 static const ClientDownloadRequest_CertificateChain& default_instance();
1018
1019 void Swap(ClientDownloadRequest_CertificateChain* other);
1020
1021 // implements Message ----------------------------------------------
1022
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;
1029
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:
1041
1042 ::std::string GetTypeName() const;
1043
1044 // nested types ----------------------------------------------------
1045
1046 typedef ClientDownloadRequest_CertificateChain_Element Element;
1047
1048 // accessors -------------------------------------------------------
1049
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();
1061
1062 // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.CertificateChain)
1063 private:
1064
1065 ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain_Element > element_;
1066
1067 mutable int _cached_size_;
1068 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
1069
1070 friend void protobuf_AddDesc_csd_2eproto();
1071 friend void protobuf_AssignDesc_csd_2eproto();
1072 friend void protobuf_ShutdownFile_csd_2eproto();
1073
1074 void InitAsDefaultInstance();
1075 static ClientDownloadRequest_CertificateChain* default_instance_;
1076 };
1077 // -------------------------------------------------------------------
1078
1079 class ClientDownloadRequest_SignatureInfo : public ::google::protobuf::MessageLite {
1080 public:
1081 ClientDownloadRequest_SignatureInfo();
1082 virtual ~ClientDownloadRequest_SignatureInfo();
1083
1084 ClientDownloadRequest_SignatureInfo(const ClientDownloadRequest_SignatureInfo& from);
1085
1086 inline ClientDownloadRequest_SignatureInfo& operator=(const ClientDownloadRequest_SignatureInfo& from) {
1087 CopyFrom(from);
1088 return *this;
1089 }
1090
1091 static const ClientDownloadRequest_SignatureInfo& default_instance();
1092
1093 void Swap(ClientDownloadRequest_SignatureInfo* other);
1094
1095 // implements Message ----------------------------------------------
1096
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;
1103
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:
1115
1116 ::std::string GetTypeName() const;
1117
1118 // nested types ----------------------------------------------------
1119
1120 // accessors -------------------------------------------------------
1121
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();
1133
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);
1140
1141 // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadRequest.SignatureInfo)
1142 private:
1143 inline void set_has_trusted();
1144 inline void clear_has_trusted();
1145
1146 ::google::protobuf::RepeatedPtrField< ::safe_browsing::ClientDownloadRequest_CertificateChain > certificate_chain_;
1147 bool trusted_;
1148
1149 mutable int _cached_size_;
1150 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
1151
1152 friend void protobuf_AddDesc_csd_2eproto();
1153 friend void protobuf_AssignDesc_csd_2eproto();
1154 friend void protobuf_ShutdownFile_csd_2eproto();
1155
1156 void InitAsDefaultInstance();
1157 static ClientDownloadRequest_SignatureInfo* default_instance_;
1158 };
1159 // -------------------------------------------------------------------
1160
1161 class ClientDownloadRequest : public ::google::protobuf::MessageLite {
1162 public:
1163 ClientDownloadRequest();
1164 virtual ~ClientDownloadRequest();
1165
1166 ClientDownloadRequest(const ClientDownloadRequest& from);
1167
1168 inline ClientDownloadRequest& operator=(const ClientDownloadRequest& from) {
1169 CopyFrom(from);
1170 return *this;
1171 }
1172
1173 static const ClientDownloadRequest& default_instance();
1174
1175 void Swap(ClientDownloadRequest* other);
1176
1177 // implements Message ----------------------------------------------
1178
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;
1185
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:
1197
1198 ::std::string GetTypeName() const;
1199
1200 // nested types ----------------------------------------------------
1201
1202 typedef ClientDownloadRequest_Digests Digests;
1203 typedef ClientDownloadRequest_Resource Resource;
1204 typedef ClientDownloadRequest_CertificateChain CertificateChain;
1205 typedef ClientDownloadRequest_SignatureInfo SignatureInfo;
1206
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;
1221
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;
1236
1237 // accessors -------------------------------------------------------
1238
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();
1249
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();
1257
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);
1264
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();
1276
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();
1284
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);
1291
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();
1302
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);
1309
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();
1320
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();
1339
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_;
1349
1350 mutable int _cached_size_;
1351 ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];
1352
1353 friend void protobuf_AddDesc_csd_2eproto();
1354 friend void protobuf_AssignDesc_csd_2eproto();
1355 friend void protobuf_ShutdownFile_csd_2eproto();
1356
1357 void InitAsDefaultInstance();
1358 static ClientDownloadRequest* default_instance_;
1359 };
1360 // -------------------------------------------------------------------
1361
1362 class ClientDownloadResponse_MoreInfo : public ::google::protobuf::MessageLite {
1363 public:
1364 ClientDownloadResponse_MoreInfo();
1365 virtual ~ClientDownloadResponse_MoreInfo();
1366
1367 ClientDownloadResponse_MoreInfo(const ClientDownloadResponse_MoreInfo& from);
1368
1369 inline ClientDownloadResponse_MoreInfo& operator=(const ClientDownloadResponse_MoreInfo& from) {
1370 CopyFrom(from);
1371 return *this;
1372 }
1373
1374 static const ClientDownloadResponse_MoreInfo& default_instance();
1375
1376 void Swap(ClientDownloadResponse_MoreInfo* other);
1377
1378 // implements Message ----------------------------------------------
1379
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;
1386
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:
1398
1399 ::std::string GetTypeName() const;
1400
1401 // nested types ----------------------------------------------------
1402
1403 // accessors -------------------------------------------------------
1404
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();
1415
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();
1426
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();
1433
1434 ::std::string* description_;
1435 ::std::string* url_;
1436
1437 mutable int _cached_size_;
1438 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
1439
1440 friend void protobuf_AddDesc_csd_2eproto();
1441 friend void protobuf_AssignDesc_csd_2eproto();
1442 friend void protobuf_ShutdownFile_csd_2eproto();
1443
1444 void InitAsDefaultInstance();
1445 static ClientDownloadResponse_MoreInfo* default_instance_;
1446 };
1447 // -------------------------------------------------------------------
1448
1449 class ClientDownloadResponse : public ::google::protobuf::MessageLite {
1450 public:
1451 ClientDownloadResponse();
1452 virtual ~ClientDownloadResponse();
1453
1454 ClientDownloadResponse(const ClientDownloadResponse& from);
1455
1456 inline ClientDownloadResponse& operator=(const ClientDownloadResponse& from) {
1457 CopyFrom(from);
1458 return *this;
1459 }
1460
1461 static const ClientDownloadResponse& default_instance();
1462
1463 void Swap(ClientDownloadResponse* other);
1464
1465 // implements Message ----------------------------------------------
1466
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;
1473
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:
1485
1486 ::std::string GetTypeName() const;
1487
1488 // nested types ----------------------------------------------------
1489
1490 typedef ClientDownloadResponse_MoreInfo MoreInfo;
1491
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;
1507
1508 // accessors -------------------------------------------------------
1509
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);
1516
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();
1524
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();
1535
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();
1544
1545 ::safe_browsing::ClientDownloadResponse_MoreInfo* more_info_;
1546 ::std::string* token_;
1547 int verdict_;
1548
1549 mutable int _cached_size_;
1550 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
1551
1552 friend void protobuf_AddDesc_csd_2eproto();
1553 friend void protobuf_AssignDesc_csd_2eproto();
1554 friend void protobuf_ShutdownFile_csd_2eproto();
1555
1556 void InitAsDefaultInstance();
1557 static ClientDownloadResponse* default_instance_;
1558 };
1559 // -------------------------------------------------------------------
1560
1561 class ClientDownloadReport_UserInformation : public ::google::protobuf::MessageLite {
1562 public:
1563 ClientDownloadReport_UserInformation();
1564 virtual ~ClientDownloadReport_UserInformation();
1565
1566 ClientDownloadReport_UserInformation(const ClientDownloadReport_UserInformation& from);
1567
1568 inline ClientDownloadReport_UserInformation& operator=(const ClientDownloadReport_UserInformation& from) {
1569 CopyFrom(from);
1570 return *this;
1571 }
1572
1573 static const ClientDownloadReport_UserInformation& default_instance();
1574
1575 void Swap(ClientDownloadReport_UserInformation* other);
1576
1577 // implements Message ----------------------------------------------
1578
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;
1585
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:
1597
1598 ::std::string GetTypeName() const;
1599
1600 // nested types ----------------------------------------------------
1601
1602 // accessors -------------------------------------------------------
1603
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();
1614
1615 // @@protoc_insertion_point(class_scope:safe_browsing.ClientDownloadReport.UserInformation)
1616 private:
1617 inline void set_has_email();
1618 inline void clear_has_email();
1619
1620 ::std::string* email_;
1621
1622 mutable int _cached_size_;
1623 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
1624
1625 friend void protobuf_AddDesc_csd_2eproto();
1626 friend void protobuf_AssignDesc_csd_2eproto();
1627 friend void protobuf_ShutdownFile_csd_2eproto();
1628
1629 void InitAsDefaultInstance();
1630 static ClientDownloadReport_UserInformation* default_instance_;
1631 };
1632 // -------------------------------------------------------------------
1633
1634 class ClientDownloadReport : public ::google::protobuf::MessageLite {
1635 public:
1636 ClientDownloadReport();
1637 virtual ~ClientDownloadReport();
1638
1639 ClientDownloadReport(const ClientDownloadReport& from);
1640
1641 inline ClientDownloadReport& operator=(const ClientDownloadReport& from) {
1642 CopyFrom(from);
1643 return *this;
1644 }
1645
1646 static const ClientDownloadReport& default_instance();
1647
1648 void Swap(ClientDownloadReport* other);
1649
1650 // implements Message ----------------------------------------------
1651
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;
1658
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:
1670
1671 ::std::string GetTypeName() const;
1672
1673 // nested types ----------------------------------------------------
1674
1675 typedef ClientDownloadReport_UserInformation UserInformation;
1676
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;
1690
1691 // accessors -------------------------------------------------------
1692
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);
1699
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();
1707
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();
1715
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();
1726
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();
1734
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();
1747
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_;
1753
1754 mutable int _cached_size_;
1755 ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
1756
1757 friend void protobuf_AddDesc_csd_2eproto();
1758 friend void protobuf_AssignDesc_csd_2eproto();
1759 friend void protobuf_ShutdownFile_csd_2eproto();
1760
1761 void InitAsDefaultInstance();
1762 static ClientDownloadReport* default_instance_;
1763 };
1764 // -------------------------------------------------------------------
1765
1766 class ClientUploadResponse : public ::google::protobuf::MessageLite {
1767 public:
1768 ClientUploadResponse();
1769 virtual ~ClientUploadResponse();
1770
1771 ClientUploadResponse(const ClientUploadResponse& from);
1772
1773 inline ClientUploadResponse& operator=(const ClientUploadResponse& from) {
1774 CopyFrom(from);
1775 return *this;
1776 }
1777
1778 static const ClientUploadResponse& default_instance();
1779
1780 void Swap(ClientUploadResponse* other);
1781
1782 // implements Message ----------------------------------------------
1783
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;
1790
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:
1802
1803 ::std::string GetTypeName() const;
1804
1805 // nested types ----------------------------------------------------
1806
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;
1819
1820 // accessors -------------------------------------------------------
1821
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);
1828
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();
1839
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();
1846
1847 ::std::string* permalink_;
1848 int status_;
1849
1850 mutable int _cached_size_;
1851 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
1852
1853 friend void protobuf_AddDesc_csd_2eproto();
1854 friend void protobuf_AssignDesc_csd_2eproto();
1855 friend void protobuf_ShutdownFile_csd_2eproto();
1856
1857 void InitAsDefaultInstance();
1858 static ClientUploadResponse* default_instance_;
1859 };
1860 // ===================================================================
1861
1862
1863 // ===================================================================
1864
1865 // ClientPhishingRequest_Feature
1866
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 }
1924
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 }
1946
1947 // -------------------------------------------------------------------
1948
1949 // ClientPhishingRequest
1950
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 }
2008
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 }
2066
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 }
2088
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 }
2110
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 }
2135
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 }
2157
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 }
2182
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 }
2240
2241 // -------------------------------------------------------------------
2242
2243 // ClientPhishingResponse
2244
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 }
2266
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 }
2310
2311 // -------------------------------------------------------------------
2312
2313 // ClientMalwareRequest_Feature
2314
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 }
2372
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 }
2394
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 }
2438
2439 // -------------------------------------------------------------------
2440
2441 // ClientMalwareRequest
2442
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 }
2500
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 }
2525
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 }
2583
2584 // -------------------------------------------------------------------
2585
2586 // ClientMalwareResponse
2587
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 }
2609
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 }
2667
2668 // -------------------------------------------------------------------
2669
2670 // ClientDownloadRequest_Digests
2671
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 }
2729
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 }
2787
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 }
2845
2846 // -------------------------------------------------------------------
2847
2848 // ClientDownloadRequest_Resource
2849
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 }
2907
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 }
2930
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 }
2988
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 }
3046
3047 // -------------------------------------------------------------------
3048
3049 // ClientDownloadRequest_CertificateChain_Element
3050
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 }
3108
3109 // -------------------------------------------------------------------
3110
3111 // ClientDownloadRequest_CertificateChain
3112
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 }
3137
3138 // -------------------------------------------------------------------
3139
3140 // ClientDownloadRequest_SignatureInfo
3141
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 }
3166
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 }
3188
3189 // -------------------------------------------------------------------
3190
3191 // ClientDownloadRequest
3192
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 }
3250
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 }
3279
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 }
3301
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 }
3326
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 }
3355
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 }
3377
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 }
3435
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 }
3458
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 }
3516
3517 // -------------------------------------------------------------------
3518
3519 // ClientDownloadResponse_MoreInfo
3520
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 }
3578
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 }
3636
3637 // -------------------------------------------------------------------
3638
3639 // ClientDownloadResponse
3640
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 }
3663
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 }
3692
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 }
3750
3751 // -------------------------------------------------------------------
3752
3753 // ClientDownloadReport_UserInformation
3754
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 }
3812
3813 // -------------------------------------------------------------------
3814
3815 // ClientDownloadReport
3816
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 }
3839
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 }
3868
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 }
3897
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 }
3955
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 }
3984
3985 // -------------------------------------------------------------------
3986
3987 // ClientUploadResponse
3988
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 }
4011
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 }
4069
4070
4071 // @@protoc_insertion_point(namespace_scope)
4072
4073 } // namespace safe_browsing
4074
4075 // @@protoc_insertion_point(global_scope)
4076
4077 #endif // PROTOBUF_csd_2eproto__INCLUDED

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial