Home | History | Annotate | Download | only in drive 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "google_apis/drive/gdata_wapi_parser.h"
      6 
      7 #include <algorithm>
      8 #include <string>
      9 
     10 #include "base/basictypes.h"
     11 #include "base/files/file_path.h"
     12 #include "base/json/json_value_converter.h"
     13 #include "base/memory/scoped_ptr.h"
     14 #include "base/strings/string_number_conversions.h"
     15 #include "base/strings/string_piece.h"
     16 #include "base/strings/string_util.h"
     17 #include "base/strings/utf_string_conversions.h"
     18 #include "base/values.h"
     19 #include "google_apis/drive/time_util.h"
     20 
     21 using base::Value;
     22 using base::DictionaryValue;
     23 using base::ListValue;
     24 
     25 namespace google_apis {
     26 
     27 namespace {
     28 
     29 // Term values for kSchemeKind category:
     30 const char kTermPrefix[] = "http://schemas.google.com/docs/2007#";
     31 
     32 // Node names.
     33 const char kEntryNode[] = "entry";
     34 
     35 // Field names.
     36 const char kAuthorField[] = "author";
     37 const char kCategoryField[] = "category";
     38 const char kChangestampField[] = "docs$changestamp.value";
     39 const char kContentField[] = "content";
     40 const char kDeletedField[] = "gd$deleted";
     41 const char kETagField[] = "gd$etag";
     42 const char kEmailField[] = "email.$t";
     43 const char kEntryField[] = "entry";
     44 const char kFeedField[] = "feed";
     45 const char kFeedLinkField[] = "gd$feedLink";
     46 const char kFileNameField[] = "docs$filename.$t";
     47 const char kHrefField[] = "href";
     48 const char kIDField[] = "id.$t";
     49 const char kItemsPerPageField[] = "openSearch$itemsPerPage.$t";
     50 const char kLabelField[] = "label";
     51 const char kLargestChangestampField[] = "docs$largestChangestamp.value";
     52 const char kLastViewedField[] = "gd$lastViewed.$t";
     53 const char kLinkField[] = "link";
     54 const char kMD5Field[] = "docs$md5Checksum.$t";
     55 const char kNameField[] = "name.$t";
     56 const char kPublishedField[] = "published.$t";
     57 const char kRelField[] = "rel";
     58 const char kRemovedField[] = "docs$removed";
     59 const char kResourceIdField[] = "gd$resourceId.$t";
     60 const char kSchemeField[] = "scheme";
     61 const char kSizeField[] = "docs$size.$t";
     62 const char kSrcField[] = "src";
     63 const char kStartIndexField[] = "openSearch$startIndex.$t";
     64 const char kSuggestedFileNameField[] = "docs$suggestedFilename.$t";
     65 const char kTermField[] = "term";
     66 const char kTitleField[] = "title";
     67 const char kTitleTField[] = "title.$t";
     68 const char kTypeField[] = "type";
     69 const char kUpdatedField[] = "updated.$t";
     70 
     71 // Link Prefixes
     72 const char kOpenWithPrefix[] = "http://schemas.google.com/docs/2007#open-with-";
     73 const size_t kOpenWithPrefixSize = arraysize(kOpenWithPrefix) - 1;
     74 
     75 struct LinkTypeMap {
     76   Link::LinkType type;
     77   const char* rel;
     78 };
     79 
     80 const LinkTypeMap kLinkTypeMap[] = {
     81     { Link::LINK_SELF,
     82       "self" },
     83     { Link::LINK_NEXT,
     84       "next" },
     85     { Link::LINK_PARENT,
     86       "http://schemas.google.com/docs/2007#parent" },
     87     { Link::LINK_ALTERNATE,
     88       "alternate"},
     89     { Link::LINK_EDIT,
     90       "edit" },
     91     { Link::LINK_EDIT_MEDIA,
     92       "edit-media" },
     93     { Link::LINK_ALT_EDIT_MEDIA,
     94       "http://schemas.google.com/docs/2007#alt-edit-media" },
     95     { Link::LINK_ALT_POST,
     96       "http://schemas.google.com/docs/2007#alt-post" },
     97     { Link::LINK_FEED,
     98       "http://schemas.google.com/g/2005#feed"},
     99     { Link::LINK_POST,
    100       "http://schemas.google.com/g/2005#post"},
    101     { Link::LINK_BATCH,
    102       "http://schemas.google.com/g/2005#batch"},
    103     { Link::LINK_THUMBNAIL,
    104       "http://schemas.google.com/docs/2007/thumbnail"},
    105     { Link::LINK_RESUMABLE_EDIT_MEDIA,
    106       "http://schemas.google.com/g/2005#resumable-edit-media"},
    107     { Link::LINK_RESUMABLE_CREATE_MEDIA,
    108       "http://schemas.google.com/g/2005#resumable-create-media"},
    109     { Link::LINK_TABLES_FEED,
    110       "http://schemas.google.com/spreadsheets/2006#tablesfeed"},
    111     { Link::LINK_WORKSHEET_FEED,
    112       "http://schemas.google.com/spreadsheets/2006#worksheetsfeed"},
    113     { Link::LINK_EMBED,
    114       "http://schemas.google.com/docs/2007#embed"},
    115     { Link::LINK_PRODUCT,
    116       "http://schemas.google.com/docs/2007#product"},
    117     { Link::LINK_ICON,
    118       "http://schemas.google.com/docs/2007#icon"},
    119     { Link::LINK_SHARE,
    120       "http://schemas.google.com/docs/2007#share"},
    121 };
    122 
    123 struct ResourceLinkTypeMap {
    124   ResourceLink::ResourceLinkType type;
    125   const char* rel;
    126 };
    127 
    128 const ResourceLinkTypeMap kFeedLinkTypeMap[] = {
    129     { ResourceLink::FEED_LINK_ACL,
    130       "http://schemas.google.com/acl/2007#accessControlList" },
    131     { ResourceLink::FEED_LINK_REVISIONS,
    132       "http://schemas.google.com/docs/2007/revisions" },
    133 };
    134 
    135 struct CategoryTypeMap {
    136   Category::CategoryType type;
    137   const char* scheme;
    138 };
    139 
    140 const CategoryTypeMap kCategoryTypeMap[] = {
    141     { Category::CATEGORY_KIND, "http://schemas.google.com/g/2005#kind" },
    142     { Category::CATEGORY_LABEL, "http://schemas.google.com/g/2005/labels" },
    143 };
    144 
    145 // Converts |url_string| to |result|.  Always returns true to be used
    146 // for JSONValueConverter::RegisterCustomField method.
    147 // TODO(mukai): make it return false in case of invalid |url_string|.
    148 bool GetGURLFromString(const base::StringPiece& url_string, GURL* result) {
    149   *result = GURL(url_string.as_string());
    150   return true;
    151 }
    152 
    153 }  // namespace
    154 
    155 ////////////////////////////////////////////////////////////////////////////////
    156 // Author implementation
    157 
    158 Author::Author() {
    159 }
    160 
    161 // static
    162 void Author::RegisterJSONConverter(
    163     base::JSONValueConverter<Author>* converter) {
    164   converter->RegisterStringField(kNameField, &Author::name_);
    165   converter->RegisterStringField(kEmailField, &Author::email_);
    166 }
    167 
    168 ////////////////////////////////////////////////////////////////////////////////
    169 // Link implementation
    170 
    171 Link::Link() : type_(Link::LINK_UNKNOWN) {
    172 }
    173 
    174 Link::~Link() {
    175 }
    176 
    177 // static
    178 bool Link::GetAppID(const base::StringPiece& rel, std::string* app_id) {
    179   DCHECK(app_id);
    180   // Fast return path if the link clearly isn't an OPEN_WITH link.
    181   if (rel.size() < kOpenWithPrefixSize) {
    182     app_id->clear();
    183     return true;
    184   }
    185 
    186   const std::string kOpenWithPrefixStr(kOpenWithPrefix);
    187   if (StartsWithASCII(rel.as_string(), kOpenWithPrefixStr, false)) {
    188     *app_id = rel.as_string().substr(kOpenWithPrefixStr.size());
    189     return true;
    190   }
    191 
    192   app_id->clear();
    193   return true;
    194 }
    195 
    196 // static.
    197 bool Link::GetLinkType(const base::StringPiece& rel, Link::LinkType* type) {
    198   DCHECK(type);
    199   for (size_t i = 0; i < arraysize(kLinkTypeMap); i++) {
    200     if (rel == kLinkTypeMap[i].rel) {
    201       *type = kLinkTypeMap[i].type;
    202       return true;
    203     }
    204   }
    205 
    206   // OPEN_WITH links have extra information at the end of the rel that is unique
    207   // for each one, so we can't just check the usual map. This check is slightly
    208   // redundant to provide a quick skip if it's obviously not an OPEN_WITH url.
    209   if (rel.size() >= kOpenWithPrefixSize &&
    210       StartsWithASCII(rel.as_string(), kOpenWithPrefix, false)) {
    211     *type = LINK_OPEN_WITH;
    212     return true;
    213   }
    214 
    215   // Let unknown link types through, just report it; if the link type is needed
    216   // in the future, add it into LinkType and kLinkTypeMap.
    217   DVLOG(1) << "Ignoring unknown link type for rel " << rel;
    218   *type = LINK_UNKNOWN;
    219   return true;
    220 }
    221 
    222 // static
    223 void Link::RegisterJSONConverter(base::JSONValueConverter<Link>* converter) {
    224   converter->RegisterCustomField<Link::LinkType>(kRelField,
    225                                                  &Link::type_,
    226                                                  &Link::GetLinkType);
    227   // We have to register kRelField twice because we extract two different pieces
    228   // of data from the same rel field.
    229   converter->RegisterCustomField<std::string>(kRelField,
    230                                               &Link::app_id_,
    231                                               &Link::GetAppID);
    232   converter->RegisterCustomField(kHrefField, &Link::href_, &GetGURLFromString);
    233   converter->RegisterStringField(kTitleField, &Link::title_);
    234   converter->RegisterStringField(kTypeField, &Link::mime_type_);
    235 }
    236 
    237 ////////////////////////////////////////////////////////////////////////////////
    238 // ResourceLink implementation
    239 
    240 ResourceLink::ResourceLink() : type_(ResourceLink::FEED_LINK_UNKNOWN) {
    241 }
    242 
    243 // static.
    244 bool ResourceLink::GetFeedLinkType(
    245     const base::StringPiece& rel, ResourceLink::ResourceLinkType* result) {
    246   for (size_t i = 0; i < arraysize(kFeedLinkTypeMap); i++) {
    247     if (rel == kFeedLinkTypeMap[i].rel) {
    248       *result = kFeedLinkTypeMap[i].type;
    249       return true;
    250     }
    251   }
    252   DVLOG(1) << "Unknown feed link type for rel " << rel;
    253   return false;
    254 }
    255 
    256 // static
    257 void ResourceLink::RegisterJSONConverter(
    258     base::JSONValueConverter<ResourceLink>* converter) {
    259   converter->RegisterCustomField<ResourceLink::ResourceLinkType>(
    260       kRelField, &ResourceLink::type_, &ResourceLink::GetFeedLinkType);
    261   converter->RegisterCustomField(
    262       kHrefField, &ResourceLink::href_, &GetGURLFromString);
    263 }
    264 
    265 ////////////////////////////////////////////////////////////////////////////////
    266 // Category implementation
    267 
    268 Category::Category() : type_(CATEGORY_UNKNOWN) {
    269 }
    270 
    271 // Converts category.scheme into CategoryType enum.
    272 bool Category::GetCategoryTypeFromScheme(
    273     const base::StringPiece& scheme, Category::CategoryType* result) {
    274   for (size_t i = 0; i < arraysize(kCategoryTypeMap); i++) {
    275     if (scheme == kCategoryTypeMap[i].scheme) {
    276       *result = kCategoryTypeMap[i].type;
    277       return true;
    278     }
    279   }
    280   DVLOG(1) << "Unknown feed link type for scheme " << scheme;
    281   return false;
    282 }
    283 
    284 // static
    285 void Category::RegisterJSONConverter(
    286     base::JSONValueConverter<Category>* converter) {
    287   converter->RegisterStringField(kLabelField, &Category::label_);
    288   converter->RegisterCustomField<Category::CategoryType>(
    289       kSchemeField, &Category::type_, &Category::GetCategoryTypeFromScheme);
    290   converter->RegisterStringField(kTermField, &Category::term_);
    291 }
    292 
    293 const Link* CommonMetadata::GetLinkByType(Link::LinkType type) const {
    294   for (size_t i = 0; i < links_.size(); ++i) {
    295     if (links_[i]->type() == type)
    296       return links_[i];
    297   }
    298   return NULL;
    299 }
    300 
    301 ////////////////////////////////////////////////////////////////////////////////
    302 // Content implementation
    303 
    304 Content::Content() {
    305 }
    306 
    307 // static
    308 void Content::RegisterJSONConverter(
    309     base::JSONValueConverter<Content>* converter) {
    310   converter->RegisterCustomField(kSrcField, &Content::url_, &GetGURLFromString);
    311   converter->RegisterStringField(kTypeField, &Content::mime_type_);
    312 }
    313 
    314 ////////////////////////////////////////////////////////////////////////////////
    315 // CommonMetadata implementation
    316 
    317 CommonMetadata::CommonMetadata() {
    318 }
    319 
    320 CommonMetadata::~CommonMetadata() {
    321 }
    322 
    323 // static
    324 template<typename CommonMetadataDescendant>
    325 void CommonMetadata::RegisterJSONConverter(
    326     base::JSONValueConverter<CommonMetadataDescendant>* converter) {
    327   converter->RegisterStringField(kETagField, &CommonMetadata::etag_);
    328   converter->template RegisterRepeatedMessage<Author>(
    329       kAuthorField, &CommonMetadata::authors_);
    330   converter->template RegisterRepeatedMessage<Link>(
    331       kLinkField, &CommonMetadata::links_);
    332   converter->template RegisterRepeatedMessage<Category>(
    333       kCategoryField, &CommonMetadata::categories_);
    334   converter->template RegisterCustomField<base::Time>(
    335       kUpdatedField, &CommonMetadata::updated_time_, &util::GetTimeFromString);
    336 }
    337 
    338 ////////////////////////////////////////////////////////////////////////////////
    339 // ResourceEntry implementation
    340 
    341 ResourceEntry::ResourceEntry()
    342     : kind_(ENTRY_KIND_UNKNOWN),
    343       file_size_(0),
    344       deleted_(false),
    345       removed_(false),
    346       changestamp_(0),
    347       image_width_(-1),
    348       image_height_(-1),
    349       image_rotation_(-1) {
    350 }
    351 
    352 ResourceEntry::~ResourceEntry() {
    353 }
    354 
    355 bool ResourceEntry::HasFieldPresent(const base::Value* value,
    356                                     bool* result) {
    357   *result = (value != NULL);
    358   return true;
    359 }
    360 
    361 bool ResourceEntry::ParseChangestamp(const base::Value* value,
    362                                      int64* result) {
    363   DCHECK(result);
    364   if (!value) {
    365     *result = 0;
    366     return true;
    367   }
    368 
    369   std::string string_value;
    370   if (value->GetAsString(&string_value) &&
    371       base::StringToInt64(string_value, result))
    372     return true;
    373 
    374   return false;
    375 }
    376 
    377 // static
    378 void ResourceEntry::RegisterJSONConverter(
    379     base::JSONValueConverter<ResourceEntry>* converter) {
    380   // Inherit the parent registrations.
    381   CommonMetadata::RegisterJSONConverter(converter);
    382   converter->RegisterStringField(
    383       kResourceIdField, &ResourceEntry::resource_id_);
    384   converter->RegisterStringField(kIDField, &ResourceEntry::id_);
    385   converter->RegisterStringField(kTitleTField, &ResourceEntry::title_);
    386   converter->RegisterCustomField<base::Time>(
    387       kPublishedField, &ResourceEntry::published_time_,
    388       &util::GetTimeFromString);
    389   converter->RegisterCustomField<base::Time>(
    390       kLastViewedField, &ResourceEntry::last_viewed_time_,
    391       &util::GetTimeFromString);
    392   converter->RegisterRepeatedMessage(
    393       kFeedLinkField, &ResourceEntry::resource_links_);
    394   converter->RegisterNestedField(kContentField, &ResourceEntry::content_);
    395 
    396   // File properties.  If the resource type is not a normal file, then
    397   // that's no problem because those feed must not have these fields
    398   // themselves, which does not report errors.
    399   converter->RegisterStringField(kFileNameField, &ResourceEntry::filename_);
    400   converter->RegisterStringField(kMD5Field, &ResourceEntry::file_md5_);
    401   converter->RegisterCustomField<int64>(
    402       kSizeField, &ResourceEntry::file_size_, &base::StringToInt64);
    403   converter->RegisterStringField(
    404       kSuggestedFileNameField, &ResourceEntry::suggested_filename_);
    405   // Deleted are treated as 'trashed' items on web client side. Removed files
    406   // are gone for good. We treat both cases as 'deleted' for this client.
    407   converter->RegisterCustomValueField<bool>(
    408       kDeletedField, &ResourceEntry::deleted_, &ResourceEntry::HasFieldPresent);
    409   converter->RegisterCustomValueField<bool>(
    410       kRemovedField, &ResourceEntry::removed_, &ResourceEntry::HasFieldPresent);
    411   converter->RegisterCustomValueField<int64>(
    412       kChangestampField, &ResourceEntry::changestamp_,
    413       &ResourceEntry::ParseChangestamp);
    414   // ImageMediaMetadata fields are not supported by WAPI.
    415 }
    416 
    417 // static
    418 ResourceEntry::ResourceEntryKind ResourceEntry::GetEntryKindFromTerm(
    419     const std::string& term) {
    420   if (!StartsWithASCII(term, kTermPrefix, false)) {
    421     DVLOG(1) << "Unexpected term prefix term " << term;
    422     return ENTRY_KIND_UNKNOWN;
    423   }
    424 
    425   std::string type = term.substr(strlen(kTermPrefix));
    426   if (type == "folder")
    427     return ENTRY_KIND_FOLDER;
    428   if (type == "file" || type == "pdf")
    429     return ENTRY_KIND_FILE;
    430 
    431   DVLOG(1) << "Unknown entry type for term " << term << ", type " << type;
    432   return ENTRY_KIND_UNKNOWN;
    433 }
    434 
    435 void ResourceEntry::FillRemainingFields() {
    436   // Set |kind_| and |labels_| based on the |categories_| in the class.
    437   // JSONValueConverter does not have the ability to catch an element in a list
    438   // based on a predicate.  Thus we need to iterate over |categories_| and
    439   // find the elements to set these fields as a post-process.
    440   for (size_t i = 0; i < categories_.size(); ++i) {
    441     const Category* category = categories_[i];
    442     if (category->type() == Category::CATEGORY_KIND)
    443       kind_ = GetEntryKindFromTerm(category->term());
    444     else if (category->type() == Category::CATEGORY_LABEL)
    445       labels_.push_back(category->label());
    446   }
    447 }
    448 
    449 // static
    450 scoped_ptr<ResourceEntry> ResourceEntry::ExtractAndParse(
    451     const base::Value& value) {
    452   const base::DictionaryValue* as_dict = NULL;
    453   const base::DictionaryValue* entry_dict = NULL;
    454   if (value.GetAsDictionary(&as_dict) &&
    455       as_dict->GetDictionary(kEntryField, &entry_dict)) {
    456     return ResourceEntry::CreateFrom(*entry_dict);
    457   }
    458   return scoped_ptr<ResourceEntry>();
    459 }
    460 
    461 // static
    462 scoped_ptr<ResourceEntry> ResourceEntry::CreateFrom(const base::Value& value) {
    463   base::JSONValueConverter<ResourceEntry> converter;
    464   scoped_ptr<ResourceEntry> entry(new ResourceEntry());
    465   if (!converter.Convert(value, entry.get())) {
    466     DVLOG(1) << "Invalid resource entry!";
    467     return scoped_ptr<ResourceEntry>();
    468   }
    469 
    470   entry->FillRemainingFields();
    471   return entry.Pass();
    472 }
    473 
    474 // static
    475 std::string ResourceEntry::GetEntryNodeName() {
    476   return kEntryNode;
    477 }
    478 
    479 ////////////////////////////////////////////////////////////////////////////////
    480 // ResourceList implementation
    481 
    482 ResourceList::ResourceList()
    483     : start_index_(0),
    484       items_per_page_(0),
    485       largest_changestamp_(0) {
    486 }
    487 
    488 ResourceList::~ResourceList() {
    489 }
    490 
    491 // static
    492 void ResourceList::RegisterJSONConverter(
    493     base::JSONValueConverter<ResourceList>* converter) {
    494   // inheritance
    495   CommonMetadata::RegisterJSONConverter(converter);
    496   // TODO(zelidrag): Once we figure out where these will be used, we should
    497   // check for valid start_index_ and items_per_page_ values.
    498   converter->RegisterCustomField<int>(
    499       kStartIndexField, &ResourceList::start_index_, &base::StringToInt);
    500   converter->RegisterCustomField<int>(
    501       kItemsPerPageField, &ResourceList::items_per_page_, &base::StringToInt);
    502   converter->RegisterStringField(kTitleTField, &ResourceList::title_);
    503   converter->RegisterRepeatedMessage(kEntryField, &ResourceList::entries_);
    504   converter->RegisterCustomField<int64>(
    505      kLargestChangestampField, &ResourceList::largest_changestamp_,
    506      &base::StringToInt64);
    507 }
    508 
    509 bool ResourceList::Parse(const base::Value& value) {
    510   base::JSONValueConverter<ResourceList> converter;
    511   if (!converter.Convert(value, this)) {
    512     DVLOG(1) << "Invalid resource list!";
    513     return false;
    514   }
    515 
    516   ScopedVector<ResourceEntry>::iterator iter = entries_.begin();
    517   while (iter != entries_.end()) {
    518     ResourceEntry* entry = (*iter);
    519     entry->FillRemainingFields();
    520     ++iter;
    521   }
    522   return true;
    523 }
    524 
    525 // static
    526 scoped_ptr<ResourceList> ResourceList::ExtractAndParse(
    527     const base::Value& value) {
    528   const base::DictionaryValue* as_dict = NULL;
    529   const base::DictionaryValue* feed_dict = NULL;
    530   if (value.GetAsDictionary(&as_dict) &&
    531       as_dict->GetDictionary(kFeedField, &feed_dict)) {
    532     return ResourceList::CreateFrom(*feed_dict);
    533   }
    534   return scoped_ptr<ResourceList>();
    535 }
    536 
    537 // static
    538 scoped_ptr<ResourceList> ResourceList::CreateFrom(const base::Value& value) {
    539   scoped_ptr<ResourceList> feed(new ResourceList());
    540   if (!feed->Parse(value)) {
    541     DVLOG(1) << "Invalid resource list!";
    542     return scoped_ptr<ResourceList>();
    543   }
    544 
    545   return feed.Pass();
    546 }
    547 
    548 bool ResourceList::GetNextFeedURL(GURL* url) const {
    549   DCHECK(url);
    550   for (size_t i = 0; i < links_.size(); ++i) {
    551     if (links_[i]->type() == Link::LINK_NEXT) {
    552       *url = links_[i]->href();
    553       return true;
    554     }
    555   }
    556   return false;
    557 }
    558 
    559 void ResourceList::ReleaseEntries(std::vector<ResourceEntry*>* entries) {
    560   entries_.release(entries);
    561 }
    562 
    563 }  // namespace google_apis
    564