1// GENERATED FILE
2// This file generated by DomDistillerJs protoc plugin.
3#include "third_party/dom_distiller_js/dom_distiller.pb.h"
4
5// proto dependencies
6
7// base dependencies
8#include "base/values.h"
9#include "base/memory/scoped_ptr.h"
10
11#include <string>
12
13namespace dom_distiller {
14  namespace proto {
15    namespace json {
16      class DistilledContent {
17       public:
18        static bool ReadFromValue(const base::Value* json, dom_distiller::proto::DistilledContent* message) {
19          const base::DictionaryValue* dict;
20          if (!json->GetAsDictionary(&dict)) goto error;
21          if (dict->HasKey("1")) {
22            std::string field_value;
23            if (!dict->GetString("1", &field_value)) {
24              goto error;
25            }
26            message->set_html(field_value);
27          }
28          return true;
29
30        error:
31          return false;
32        }
33
34        static scoped_ptr<base::Value> WriteToValue(const dom_distiller::proto::DistilledContent& message) {
35          scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
36          if (message.has_html()) {
37            dict->SetString("1", message.html());
38          }
39          return dict.PassAs<base::Value>();
40        }
41      };
42
43      class PaginationInfo {
44       public:
45        static bool ReadFromValue(const base::Value* json, dom_distiller::proto::PaginationInfo* message) {
46          const base::DictionaryValue* dict;
47          if (!json->GetAsDictionary(&dict)) goto error;
48          if (dict->HasKey("1")) {
49            std::string field_value;
50            if (!dict->GetString("1", &field_value)) {
51              goto error;
52            }
53            message->set_next_page(field_value);
54          }
55          if (dict->HasKey("2")) {
56            std::string field_value;
57            if (!dict->GetString("2", &field_value)) {
58              goto error;
59            }
60            message->set_prev_page(field_value);
61          }
62          if (dict->HasKey("3")) {
63            std::string field_value;
64            if (!dict->GetString("3", &field_value)) {
65              goto error;
66            }
67            message->set_canonical_page(field_value);
68          }
69          return true;
70
71        error:
72          return false;
73        }
74
75        static scoped_ptr<base::Value> WriteToValue(const dom_distiller::proto::PaginationInfo& message) {
76          scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
77          if (message.has_next_page()) {
78            dict->SetString("1", message.next_page());
79          }
80          if (message.has_prev_page()) {
81            dict->SetString("2", message.prev_page());
82          }
83          if (message.has_canonical_page()) {
84            dict->SetString("3", message.canonical_page());
85          }
86          return dict.PassAs<base::Value>();
87        }
88      };
89
90      class MarkupArticle {
91       public:
92        static bool ReadFromValue(const base::Value* json, dom_distiller::proto::MarkupArticle* message) {
93          const base::DictionaryValue* dict;
94          if (!json->GetAsDictionary(&dict)) goto error;
95          if (dict->HasKey("1")) {
96            std::string field_value;
97            if (!dict->GetString("1", &field_value)) {
98              goto error;
99            }
100            message->set_published_time(field_value);
101          }
102          if (dict->HasKey("2")) {
103            std::string field_value;
104            if (!dict->GetString("2", &field_value)) {
105              goto error;
106            }
107            message->set_modified_time(field_value);
108          }
109          if (dict->HasKey("3")) {
110            std::string field_value;
111            if (!dict->GetString("3", &field_value)) {
112              goto error;
113            }
114            message->set_expiration_time(field_value);
115          }
116          if (dict->HasKey("4")) {
117            std::string field_value;
118            if (!dict->GetString("4", &field_value)) {
119              goto error;
120            }
121            message->set_section(field_value);
122          }
123          if (dict->HasKey("5")) {
124            const base::ListValue* field_list;
125            if (!dict->GetList("5", &field_list)) {
126              goto error;
127            }
128            for (size_t i = 0; i < field_list->GetSize(); ++i) {
129              std::string field_value;
130              if (!field_list->GetString(i, &field_value)) {
131                goto error;
132              }
133              message->add_authors(field_value);
134            }
135          }
136          return true;
137
138        error:
139          return false;
140        }
141
142        static scoped_ptr<base::Value> WriteToValue(const dom_distiller::proto::MarkupArticle& message) {
143          scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
144          if (message.has_published_time()) {
145            dict->SetString("1", message.published_time());
146          }
147          if (message.has_modified_time()) {
148            dict->SetString("2", message.modified_time());
149          }
150          if (message.has_expiration_time()) {
151            dict->SetString("3", message.expiration_time());
152          }
153          if (message.has_section()) {
154            dict->SetString("4", message.section());
155          }
156          base::ListValue* field_list = new base::ListValue();
157          dict->Set("5", field_list);
158          for (int i = 0; i < message.authors_size(); ++i) {
159            field_list->AppendString(message.authors(i));
160          }
161          return dict.PassAs<base::Value>();
162        }
163      };
164
165      class MarkupImage {
166       public:
167        static bool ReadFromValue(const base::Value* json, dom_distiller::proto::MarkupImage* message) {
168          const base::DictionaryValue* dict;
169          if (!json->GetAsDictionary(&dict)) goto error;
170          if (dict->HasKey("1")) {
171            std::string field_value;
172            if (!dict->GetString("1", &field_value)) {
173              goto error;
174            }
175            message->set_url(field_value);
176          }
177          if (dict->HasKey("2")) {
178            std::string field_value;
179            if (!dict->GetString("2", &field_value)) {
180              goto error;
181            }
182            message->set_secure_url(field_value);
183          }
184          if (dict->HasKey("3")) {
185            std::string field_value;
186            if (!dict->GetString("3", &field_value)) {
187              goto error;
188            }
189            message->set_type(field_value);
190          }
191          if (dict->HasKey("4")) {
192            std::string field_value;
193            if (!dict->GetString("4", &field_value)) {
194              goto error;
195            }
196            message->set_caption(field_value);
197          }
198          if (dict->HasKey("5")) {
199            int field_value;
200            if (!dict->GetInteger("5", &field_value)) {
201              goto error;
202            }
203            message->set_width(field_value);
204          }
205          if (dict->HasKey("6")) {
206            int field_value;
207            if (!dict->GetInteger("6", &field_value)) {
208              goto error;
209            }
210            message->set_height(field_value);
211          }
212          return true;
213
214        error:
215          return false;
216        }
217
218        static scoped_ptr<base::Value> WriteToValue(const dom_distiller::proto::MarkupImage& message) {
219          scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
220          if (message.has_url()) {
221            dict->SetString("1", message.url());
222          }
223          if (message.has_secure_url()) {
224            dict->SetString("2", message.secure_url());
225          }
226          if (message.has_type()) {
227            dict->SetString("3", message.type());
228          }
229          if (message.has_caption()) {
230            dict->SetString("4", message.caption());
231          }
232          if (message.has_width()) {
233            dict->SetInteger("5", message.width());
234          }
235          if (message.has_height()) {
236            dict->SetInteger("6", message.height());
237          }
238          return dict.PassAs<base::Value>();
239        }
240      };
241
242      class MarkupInfo {
243       public:
244        static bool ReadFromValue(const base::Value* json, dom_distiller::proto::MarkupInfo* message) {
245          const base::DictionaryValue* dict;
246          if (!json->GetAsDictionary(&dict)) goto error;
247          if (dict->HasKey("1")) {
248            std::string field_value;
249            if (!dict->GetString("1", &field_value)) {
250              goto error;
251            }
252            message->set_title(field_value);
253          }
254          if (dict->HasKey("2")) {
255            std::string field_value;
256            if (!dict->GetString("2", &field_value)) {
257              goto error;
258            }
259            message->set_type(field_value);
260          }
261          if (dict->HasKey("3")) {
262            std::string field_value;
263            if (!dict->GetString("3", &field_value)) {
264              goto error;
265            }
266            message->set_url(field_value);
267          }
268          if (dict->HasKey("4")) {
269            std::string field_value;
270            if (!dict->GetString("4", &field_value)) {
271              goto error;
272            }
273            message->set_description(field_value);
274          }
275          if (dict->HasKey("5")) {
276            std::string field_value;
277            if (!dict->GetString("5", &field_value)) {
278              goto error;
279            }
280            message->set_publisher(field_value);
281          }
282          if (dict->HasKey("6")) {
283            std::string field_value;
284            if (!dict->GetString("6", &field_value)) {
285              goto error;
286            }
287            message->set_copyright(field_value);
288          }
289          if (dict->HasKey("7")) {
290            std::string field_value;
291            if (!dict->GetString("7", &field_value)) {
292              goto error;
293            }
294            message->set_author(field_value);
295          }
296          if (dict->HasKey("8")) {
297            const base::Value* inner_message_value;
298            if (!dict->Get("8", &inner_message_value)) {
299              goto error;
300            }
301            if (!dom_distiller::proto::json::MarkupArticle::ReadFromValue(inner_message_value, message->mutable_article())) {
302              goto error;
303            }
304          }
305          if (dict->HasKey("9")) {
306            const base::ListValue* field_list;
307            if (!dict->GetList("9", &field_list)) {
308              goto error;
309            }
310            for (size_t i = 0; i < field_list->GetSize(); ++i) {
311              const base::Value* inner_message_value;
312              if (!field_list->Get(i, &inner_message_value)) {
313                goto error;
314              }
315              if (!dom_distiller::proto::json::MarkupImage::ReadFromValue(inner_message_value, message->add_images())) {
316                goto error;
317              }
318            }
319          }
320          return true;
321
322        error:
323          return false;
324        }
325
326        static scoped_ptr<base::Value> WriteToValue(const dom_distiller::proto::MarkupInfo& message) {
327          scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
328          if (message.has_title()) {
329            dict->SetString("1", message.title());
330          }
331          if (message.has_type()) {
332            dict->SetString("2", message.type());
333          }
334          if (message.has_url()) {
335            dict->SetString("3", message.url());
336          }
337          if (message.has_description()) {
338            dict->SetString("4", message.description());
339          }
340          if (message.has_publisher()) {
341            dict->SetString("5", message.publisher());
342          }
343          if (message.has_copyright()) {
344            dict->SetString("6", message.copyright());
345          }
346          if (message.has_author()) {
347            dict->SetString("7", message.author());
348          }
349          if (message.has_article()) {
350            scoped_ptr<base::Value> inner_message_value =
351                dom_distiller::proto::json::MarkupArticle::WriteToValue(message.article());
352            dict->Set("8", inner_message_value.release());
353          }
354          base::ListValue* field_list = new base::ListValue();
355          dict->Set("9", field_list);
356          for (int i = 0; i < message.images_size(); ++i) {
357            scoped_ptr<base::Value> inner_message_value =
358                dom_distiller::proto::json::MarkupImage::WriteToValue(message.images(i));
359            field_list->Append(inner_message_value.release());
360          }
361          return dict.PassAs<base::Value>();
362        }
363      };
364
365      class TimingInfo {
366       public:
367        static bool ReadFromValue(const base::Value* json, dom_distiller::proto::TimingInfo* message) {
368          const base::DictionaryValue* dict;
369          if (!json->GetAsDictionary(&dict)) goto error;
370          if (dict->HasKey("1")) {
371            double field_value;
372            if (!dict->GetDouble("1", &field_value)) {
373              goto error;
374            }
375            message->set_markup_parsing_time(field_value);
376          }
377          if (dict->HasKey("2")) {
378            double field_value;
379            if (!dict->GetDouble("2", &field_value)) {
380              goto error;
381            }
382            message->set_document_construction_time(field_value);
383          }
384          if (dict->HasKey("3")) {
385            double field_value;
386            if (!dict->GetDouble("3", &field_value)) {
387              goto error;
388            }
389            message->set_article_processing_time(field_value);
390          }
391          if (dict->HasKey("4")) {
392            double field_value;
393            if (!dict->GetDouble("4", &field_value)) {
394              goto error;
395            }
396            message->set_formatting_time(field_value);
397          }
398          if (dict->HasKey("5")) {
399            double field_value;
400            if (!dict->GetDouble("5", &field_value)) {
401              goto error;
402            }
403            message->set_total_time(field_value);
404          }
405          return true;
406
407        error:
408          return false;
409        }
410
411        static scoped_ptr<base::Value> WriteToValue(const dom_distiller::proto::TimingInfo& message) {
412          scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
413          if (message.has_markup_parsing_time()) {
414            dict->SetDouble("1", message.markup_parsing_time());
415          }
416          if (message.has_document_construction_time()) {
417            dict->SetDouble("2", message.document_construction_time());
418          }
419          if (message.has_article_processing_time()) {
420            dict->SetDouble("3", message.article_processing_time());
421          }
422          if (message.has_formatting_time()) {
423            dict->SetDouble("4", message.formatting_time());
424          }
425          if (message.has_total_time()) {
426            dict->SetDouble("5", message.total_time());
427          }
428          return dict.PassAs<base::Value>();
429        }
430      };
431
432      class DebugInfo {
433       public:
434        static bool ReadFromValue(const base::Value* json, dom_distiller::proto::DebugInfo* message) {
435          const base::DictionaryValue* dict;
436          if (!json->GetAsDictionary(&dict)) goto error;
437          if (dict->HasKey("1")) {
438            std::string field_value;
439            if (!dict->GetString("1", &field_value)) {
440              goto error;
441            }
442            message->set_log(field_value);
443          }
444          return true;
445
446        error:
447          return false;
448        }
449
450        static scoped_ptr<base::Value> WriteToValue(const dom_distiller::proto::DebugInfo& message) {
451          scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
452          if (message.has_log()) {
453            dict->SetString("1", message.log());
454          }
455          return dict.PassAs<base::Value>();
456        }
457      };
458
459      class StatisticsInfo {
460       public:
461        static bool ReadFromValue(const base::Value* json, dom_distiller::proto::StatisticsInfo* message) {
462          const base::DictionaryValue* dict;
463          if (!json->GetAsDictionary(&dict)) goto error;
464          if (dict->HasKey("1")) {
465            int field_value;
466            if (!dict->GetInteger("1", &field_value)) {
467              goto error;
468            }
469            message->set_word_count(field_value);
470          }
471          return true;
472
473        error:
474          return false;
475        }
476
477        static scoped_ptr<base::Value> WriteToValue(const dom_distiller::proto::StatisticsInfo& message) {
478          scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
479          if (message.has_word_count()) {
480            dict->SetInteger("1", message.word_count());
481          }
482          return dict.PassAs<base::Value>();
483        }
484      };
485
486      class DomDistillerResult {
487       public:
488        static bool ReadFromValue(const base::Value* json, dom_distiller::proto::DomDistillerResult* message) {
489          const base::DictionaryValue* dict;
490          if (!json->GetAsDictionary(&dict)) goto error;
491          if (dict->HasKey("1")) {
492            std::string field_value;
493            if (!dict->GetString("1", &field_value)) {
494              goto error;
495            }
496            message->set_title(field_value);
497          }
498          if (dict->HasKey("2")) {
499            const base::Value* inner_message_value;
500            if (!dict->Get("2", &inner_message_value)) {
501              goto error;
502            }
503            if (!dom_distiller::proto::json::DistilledContent::ReadFromValue(inner_message_value, message->mutable_distilled_content())) {
504              goto error;
505            }
506          }
507          if (dict->HasKey("3")) {
508            const base::Value* inner_message_value;
509            if (!dict->Get("3", &inner_message_value)) {
510              goto error;
511            }
512            if (!dom_distiller::proto::json::PaginationInfo::ReadFromValue(inner_message_value, message->mutable_pagination_info())) {
513              goto error;
514            }
515          }
516          if (dict->HasKey("4")) {
517            const base::ListValue* field_list;
518            if (!dict->GetList("4", &field_list)) {
519              goto error;
520            }
521            for (size_t i = 0; i < field_list->GetSize(); ++i) {
522              std::string field_value;
523              if (!field_list->GetString(i, &field_value)) {
524                goto error;
525              }
526              message->add_image_urls(field_value);
527            }
528          }
529          if (dict->HasKey("5")) {
530            const base::Value* inner_message_value;
531            if (!dict->Get("5", &inner_message_value)) {
532              goto error;
533            }
534            if (!dom_distiller::proto::json::MarkupInfo::ReadFromValue(inner_message_value, message->mutable_markup_info())) {
535              goto error;
536            }
537          }
538          if (dict->HasKey("6")) {
539            const base::Value* inner_message_value;
540            if (!dict->Get("6", &inner_message_value)) {
541              goto error;
542            }
543            if (!dom_distiller::proto::json::TimingInfo::ReadFromValue(inner_message_value, message->mutable_timing_info())) {
544              goto error;
545            }
546          }
547          if (dict->HasKey("7")) {
548            const base::Value* inner_message_value;
549            if (!dict->Get("7", &inner_message_value)) {
550              goto error;
551            }
552            if (!dom_distiller::proto::json::DebugInfo::ReadFromValue(inner_message_value, message->mutable_debug_info())) {
553              goto error;
554            }
555          }
556          if (dict->HasKey("8")) {
557            const base::Value* inner_message_value;
558            if (!dict->Get("8", &inner_message_value)) {
559              goto error;
560            }
561            if (!dom_distiller::proto::json::StatisticsInfo::ReadFromValue(inner_message_value, message->mutable_statistics_info())) {
562              goto error;
563            }
564          }
565          return true;
566
567        error:
568          return false;
569        }
570
571        static scoped_ptr<base::Value> WriteToValue(const dom_distiller::proto::DomDistillerResult& message) {
572          scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
573          if (message.has_title()) {
574            dict->SetString("1", message.title());
575          }
576          if (message.has_distilled_content()) {
577            scoped_ptr<base::Value> inner_message_value =
578                dom_distiller::proto::json::DistilledContent::WriteToValue(message.distilled_content());
579            dict->Set("2", inner_message_value.release());
580          }
581          if (message.has_pagination_info()) {
582            scoped_ptr<base::Value> inner_message_value =
583                dom_distiller::proto::json::PaginationInfo::WriteToValue(message.pagination_info());
584            dict->Set("3", inner_message_value.release());
585          }
586          base::ListValue* field_list = new base::ListValue();
587          dict->Set("4", field_list);
588          for (int i = 0; i < message.image_urls_size(); ++i) {
589            field_list->AppendString(message.image_urls(i));
590          }
591          if (message.has_markup_info()) {
592            scoped_ptr<base::Value> inner_message_value =
593                dom_distiller::proto::json::MarkupInfo::WriteToValue(message.markup_info());
594            dict->Set("5", inner_message_value.release());
595          }
596          if (message.has_timing_info()) {
597            scoped_ptr<base::Value> inner_message_value =
598                dom_distiller::proto::json::TimingInfo::WriteToValue(message.timing_info());
599            dict->Set("6", inner_message_value.release());
600          }
601          if (message.has_debug_info()) {
602            scoped_ptr<base::Value> inner_message_value =
603                dom_distiller::proto::json::DebugInfo::WriteToValue(message.debug_info());
604            dict->Set("7", inner_message_value.release());
605          }
606          if (message.has_statistics_info()) {
607            scoped_ptr<base::Value> inner_message_value =
608                dom_distiller::proto::json::StatisticsInfo::WriteToValue(message.statistics_info());
609            dict->Set("8", inner_message_value.release());
610          }
611          return dict.PassAs<base::Value>();
612        }
613      };
614
615      class DomDistillerOptions {
616       public:
617        static bool ReadFromValue(const base::Value* json, dom_distiller::proto::DomDistillerOptions* message) {
618          const base::DictionaryValue* dict;
619          if (!json->GetAsDictionary(&dict)) goto error;
620          if (dict->HasKey("1")) {
621            bool field_value;
622            if (!dict->GetBoolean("1", &field_value)) {
623              goto error;
624            }
625            message->set_extract_text_only(field_value);
626          }
627          if (dict->HasKey("2")) {
628            int field_value;
629            if (!dict->GetInteger("2", &field_value)) {
630              goto error;
631            }
632            message->set_debug_level(field_value);
633          }
634          return true;
635
636        error:
637          return false;
638        }
639
640        static scoped_ptr<base::Value> WriteToValue(const dom_distiller::proto::DomDistillerOptions& message) {
641          scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
642          if (message.has_extract_text_only()) {
643            dict->SetBoolean("1", message.extract_text_only());
644          }
645          if (message.has_debug_level()) {
646            dict->SetInteger("2", message.debug_level());
647          }
648          return dict.PassAs<base::Value>();
649        }
650      };
651
652    }
653  }
654}
655