src/third_party/dom_distiller_js/package/proto_gen/third_party/dom_distiller_js/dom_distiller_json_converter.h

   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
  13 namespace 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.Pass();
  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.Pass();
  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.Pass();
 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.Pass();
 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.Pass();
 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.Pass();
 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.Pass();
 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.Pass();
 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           if (dict->HasKey("9")) {
 566             std::string field_value;
 567             if (!dict->GetString("9", &field_value)) {
 568               goto error;
 569             }
 570             message->set_text_direction(field_value);
 571           }
 572           return true;
 573
 574         error:
 575           return false;
 576         }
 577
 578         static scoped_ptr<base::Value> WriteToValue(const dom_distiller::proto::DomDistillerResult& message) {
 579           scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 580           if (message.has_title()) {
 581             dict->SetString("1", message.title());
 582           }
 583           if (message.has_distilled_content()) {
 584             scoped_ptr<base::Value> inner_message_value =
 585                 dom_distiller::proto::json::DistilledContent::WriteToValue(message.distilled_content());
 586             dict->Set("2", inner_message_value.release());
 587           }
 588           if (message.has_pagination_info()) {
 589             scoped_ptr<base::Value> inner_message_value =
 590                 dom_distiller::proto::json::PaginationInfo::WriteToValue(message.pagination_info());
 591             dict->Set("3", inner_message_value.release());
 592           }
 593           base::ListValue* field_list = new base::ListValue();
 594           dict->Set("4", field_list);
 595           for (int i = 0; i < message.image_urls_size(); ++i) {
 596             field_list->AppendString(message.image_urls(i));
 597           }
 598           if (message.has_markup_info()) {
 599             scoped_ptr<base::Value> inner_message_value =
 600                 dom_distiller::proto::json::MarkupInfo::WriteToValue(message.markup_info());
 601             dict->Set("5", inner_message_value.release());
 602           }
 603           if (message.has_timing_info()) {
 604             scoped_ptr<base::Value> inner_message_value =
 605                 dom_distiller::proto::json::TimingInfo::WriteToValue(message.timing_info());
 606             dict->Set("6", inner_message_value.release());
 607           }
 608           if (message.has_debug_info()) {
 609             scoped_ptr<base::Value> inner_message_value =
 610                 dom_distiller::proto::json::DebugInfo::WriteToValue(message.debug_info());
 611             dict->Set("7", inner_message_value.release());
 612           }
 613           if (message.has_statistics_info()) {
 614             scoped_ptr<base::Value> inner_message_value =
 615                 dom_distiller::proto::json::StatisticsInfo::WriteToValue(message.statistics_info());
 616             dict->Set("8", inner_message_value.release());
 617           }
 618           if (message.has_text_direction()) {
 619             dict->SetString("9", message.text_direction());
 620           }
 621           return dict.Pass();
 622         }
 623       };
 624
 625       class DomDistillerOptions {
 626        public:
 627         static bool ReadFromValue(const base::Value* json, dom_distiller::proto::DomDistillerOptions* message) {
 628           const base::DictionaryValue* dict;
 629           if (!json->GetAsDictionary(&dict)) goto error;
 630           if (dict->HasKey("1")) {
 631             bool field_value;
 632             if (!dict->GetBoolean("1", &field_value)) {
 633               goto error;
 634             }
 635             message->set_extract_text_only(field_value);
 636           }
 637           if (dict->HasKey("2")) {
 638             int field_value;
 639             if (!dict->GetInteger("2", &field_value)) {
 640               goto error;
 641             }
 642             message->set_debug_level(field_value);
 643           }
 644           if (dict->HasKey("3")) {
 645             std::string field_value;
 646             if (!dict->GetString("3", &field_value)) {
 647               goto error;
 648             }
 649             message->set_original_domain(field_value);
 650           }
 651           return true;
 652
 653         error:
 654           return false;
 655         }
 656
 657         static scoped_ptr<base::Value> WriteToValue(const dom_distiller::proto::DomDistillerOptions& message) {
 658           scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 659           if (message.has_extract_text_only()) {
 660             dict->SetBoolean("1", message.extract_text_only());
 661           }
 662           if (message.has_debug_level()) {
 663             dict->SetInteger("2", message.debug_level());
 664           }
 665           if (message.has_original_domain()) {
 666             dict->SetString("3", message.original_domain());
 667           }
 668           return dict.Pass();
 669         }
 670       };
 671
 672     }
 673   }
 674 }