1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_GOOGLE_APIS_GDATA_WAPI_PARSER_H_
#define CHROME_BROWSER_GOOGLE_APIS_GDATA_WAPI_PARSER_H_
#include <string>
#include <utility>
#include <vector>
#include "base/compiler_specific.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/scoped_vector.h"
#include "base/string_piece.h"
#include "base/time.h"
#include "chrome/browser/google_apis/drive_entry_kinds.h"
#include "googleurl/src/gurl.h"
class FilePath;
class Profile;
namespace base {
class Value;
class DictionaryValue;
template <class StructType>
class JSONValueConverter;
namespace internal {
template <class NestedType>
class RepeatedMessageConverter;
} // namespace internal
} // namespace base
// Defines data elements of Google Documents API as described in
// http://code.google.com/apis/documents/.
namespace google_apis {
// TODO(kochi): These forward declarations will be unnecessary once
// http://crbug.com/142293 is resolved.
class ChangeList;
class ChangeResource;
class FileList;
class FileResource;
// Defines link (URL) of an entity (document, file, feed...). Each entity could
// have more than one link representing it.
class Link {
public:
enum LinkType {
LINK_UNKNOWN,
LINK_SELF,
LINK_NEXT,
LINK_PARENT,
LINK_ALTERNATE,
LINK_EDIT,
LINK_EDIT_MEDIA,
LINK_ALT_EDIT_MEDIA,
LINK_ALT_POST,
LINK_FEED,
LINK_POST,
LINK_BATCH,
LINK_RESUMABLE_EDIT_MEDIA,
LINK_RESUMABLE_CREATE_MEDIA,
LINK_TABLES_FEED,
LINK_WORKSHEET_FEED,
LINK_THUMBNAIL,
LINK_EMBED,
LINK_PRODUCT,
LINK_ICON,
LINK_OPEN_WITH,
LINK_SHARE,
};
Link();
~Link();
// Registers the mapping between JSON field names and the members in
// this class.
static void RegisterJSONConverter(base::JSONValueConverter<Link>* converter);
// Type of the link.
LinkType type() const { return type_; }
// URL of the link.
const GURL& href() const { return href_; }
// Title of the link.
const string16& title() const { return title_; }
// For OPEN_WITH links, this contains the application ID. For all other link
// types, it is the empty string.
const std::string& app_id() const { return app_id_; }
// Link MIME type.
const std::string& mime_type() const { return mime_type_; }
void set_type(LinkType type) { type_ = type; }
void set_href(const GURL& href) { href_ = href; }
void set_title(const string16& title) { title_ = title; }
void set_app_id(const std::string& app_id) { app_id_ = app_id; }
void set_mime_type(const std::string& mime_type) { mime_type_ = mime_type; }
private:
friend class ResourceEntry;
// Converts value of link.rel into LinkType. Outputs to |type| and returns
// true when |rel| has a valid value. Otherwise does nothing and returns
// false.
static bool GetLinkType(const base::StringPiece& rel, LinkType* type);
// Converts value of link.rel to application ID, if there is one embedded in
// the link.rel field. Outputs to |app_id| and returns true when |rel| has a
// valid value. Otherwise does nothing and returns false.
static bool GetAppID(const base::StringPiece& rel, std::string* app_id);
LinkType type_;
GURL href_;
string16 title_;
std::string app_id_;
std::string mime_type_;
DISALLOW_COPY_AND_ASSIGN(Link);
};
// Feed links define links (URLs) to special list of entries (i.e. list of
// previous document revisions).
class FeedLink {
public:
enum FeedLinkType {
FEED_LINK_UNKNOWN,
FEED_LINK_ACL,
FEED_LINK_REVISIONS,
};
FeedLink();
// Registers the mapping between JSON field names and the members in
// this class.
static void RegisterJSONConverter(
base::JSONValueConverter<FeedLink>* converter);
// MIME type of the feed.
FeedLinkType type() const { return type_; }
// URL of the feed.
const GURL& href() const { return href_; }
void set_type(FeedLinkType type) { type_ = type; }
void set_href(const GURL& href) { href_ = href; }
private:
friend class ResourceEntry;
// Converts value of gd$feedLink.rel into FeedLinkType enum.
// Outputs to |result| and returns true when |rel| has a valid
// value. Otherwise does nothing and returns false.
static bool GetFeedLinkType(
const base::StringPiece& rel, FeedLinkType* result);
FeedLinkType type_;
GURL href_;
DISALLOW_COPY_AND_ASSIGN(FeedLink);
};
// Author represents an author of an entity.
class Author {
public:
Author();
// Registers the mapping between JSON field names and the members in
// this class.
static void RegisterJSONConverter(
base::JSONValueConverter<Author>* converter);
// Getters.
const string16& name() const { return name_; }
const std::string& email() const { return email_; }
void set_name(const string16& name) { name_ = name; }
void set_email(const std::string& email) { email_ = email; }
private:
friend class ResourceEntry;
string16 name_;
std::string email_;
DISALLOW_COPY_AND_ASSIGN(Author);
};
// Entry category.
class Category {
public:
enum CategoryType {
CATEGORY_UNKNOWN,
CATEGORY_ITEM,
CATEGORY_KIND,
CATEGORY_LABEL,
};
Category();
// Registers the mapping between JSON field names and the members in
// this class.
static void RegisterJSONConverter(
base::JSONValueConverter<Category>* converter);
// Category label.
const string16& label() const { return label_; }
// Category type.
CategoryType type() const { return type_; }
// Category term.
const std::string& term() const { return term_; }
void set_label(const string16& label) { label_ = label; }
void set_type(CategoryType type) { type_ = type; }
void set_term(const std::string& term) { term_ = term; }
private:
friend class ResourceEntry;
// Converts category scheme into CategoryType enum. For example,
// http://schemas.google.com/g/2005#kind => Category::CATEGORY_KIND
// Returns false and does not change |result| when |scheme| has an
// unrecognizable value.
static bool GetCategoryTypeFromScheme(
const base::StringPiece& scheme, CategoryType* result);
string16 label_;
CategoryType type_;
std::string term_;
DISALLOW_COPY_AND_ASSIGN(Category);
};
// Content details of a resource: mime-type, url, and so on.
class Content {
public:
Content();
// Registers the mapping between JSON field names and the members in
// this class.
static void RegisterJSONConverter(
base::JSONValueConverter<Content>* converter);
const GURL& url() const { return url_; }
const std::string& mime_type() const { return mime_type_; }
void set_url(const GURL& url) { url_ = url; }
void set_mime_type(const std::string& mime_type) { mime_type_ = mime_type; }
private:
friend class ResourceEntry;
GURL url_;
std::string mime_type_;
};
// This stores a representation of an application icon as registered with the
// installed applications section of the account metadata feed. There can be
// multiple icons registered for each application, differing in size, category
// and MIME type.
class AppIcon {
public:
enum IconCategory {
ICON_UNKNOWN, // Uninitialized state
ICON_DOCUMENT, // Document icon for various MIME types
ICON_APPLICATION, // Application icon for various MIME types
ICON_SHARED_DOCUMENT, // Icon for documents that are shared from other
// users.
};
AppIcon();
~AppIcon();
// Registers the mapping between JSON field names and the members in
// this class.
static void RegisterJSONConverter(
base::JSONValueConverter<AppIcon>* converter);
// Category of the icon.
IconCategory category() const { return category_; }
// Size in pixels of one side of the icon (icons are always square).
int icon_side_length() const { return icon_side_length_; }
// Get a list of links available for this AppIcon.
const ScopedVector<Link>& links() const { return links_; }
// Get the icon URL from the internal list of links. Returns the first
// icon URL found in the list.
GURL GetIconURL() const;
void set_category(IconCategory category) { category_ = category; }
void set_icon_side_length(int icon_side_length) {
icon_side_length_ = icon_side_length;
}
void set_links(ScopedVector<Link>* links) { links_.swap(*links); }
private:
// Extracts the icon category from the given string. Returns false and does
// not change |result| when |scheme| has an unrecognizable value.
static bool GetIconCategory(const base::StringPiece& category,
IconCategory* result);
IconCategory category_;
int icon_side_length_;
ScopedVector<Link> links_;
DISALLOW_COPY_AND_ASSIGN(AppIcon);
};
// Base class for feed entries. This class defines fields commonly used by
// various feeds.
class FeedEntry {
public:
FeedEntry();
virtual ~FeedEntry();
// Returns a link of a given |type| for this entry. If not found, it returns
// NULL.
const Link* GetLinkByType(Link::LinkType type) const;
// Entry update time.
base::Time updated_time() const { return updated_time_; }
// Entry ETag.
const std::string& etag() const { return etag_; }
// List of entry authors.
const ScopedVector<Author>& authors() const { return authors_; }
// List of entry links.
const ScopedVector<Link>& links() const { return links_; }
ScopedVector<Link>* mutable_links() { return &links_; }
// List of entry categories.
const ScopedVector<Category>& categories() const { return categories_; }
void set_etag(const std::string& etag) { etag_ = etag; }
void set_authors(ScopedVector<Author>* authors) {
authors_.swap(*authors);
}
void set_links(ScopedVector<Link>* links) {
links_.swap(*links);
}
void set_categories(ScopedVector<Category>* categories) {
categories_.swap(*categories);
}
void set_updated_time(const base::Time& updated_time) {
updated_time_ = updated_time;
}
protected:
// Registers the mapping between JSON field names and the members in
// this class.
template<typename FeedEntryDescendant>
static void RegisterJSONConverter(
base::JSONValueConverter<FeedEntryDescendant>* converter);
std::string etag_;
ScopedVector<Author> authors_;
ScopedVector<Link> links_;
ScopedVector<Category> categories_;
base::Time updated_time_;
DISALLOW_COPY_AND_ASSIGN(FeedEntry);
};
// This class represents a resource entry. A resource is a generic term which
// refers to a file and a directory.
class ResourceEntry : public FeedEntry {
public:
ResourceEntry();
virtual ~ResourceEntry();
// Extracts "entry" dictionary from the JSON value, and parse the contents,
// using CreateFrom(). Returns NULL on failure. The input JSON data, coming
// from the gdata server, looks like:
//
// {
// "encoding": "UTF-8",
// "entry": { ... }, // This function will extract this and parse.
// "version": "1.0"
// }
//
// The caller should delete the returned object.
static scoped_ptr<ResourceEntry> ExtractAndParse(const base::Value& value);
// Creates resource entry from parsed JSON Value. You should call
// this instead of instantiating JSONValueConverter by yourself
// because this method does some post-process for some fields. See
// FillRemainingFields comment and implementation for the details.
static scoped_ptr<ResourceEntry> CreateFrom(const base::Value& value);
// Creates resource entry from FileResource.
// TODO(kochi): This should go away soon. http://crbug.com/142293
static scoped_ptr<ResourceEntry> CreateFromFileResource(
const FileResource& file);
// Creates resource entry from ChangeResource.
// Todo(Kochi): This should go away soon. http://crbug.com/142293
static scoped_ptr<ResourceEntry> CreateFromChangeResource(
const ChangeResource& change);
// Returns name of entry node.
static std::string GetEntryNodeName();
// Registers the mapping between JSON field names and the members in
// this class.
static void RegisterJSONConverter(
base::JSONValueConverter<ResourceEntry>* converter);
// Sets true to |result| if the field exists.
// Always returns true even when the field does not exist.
static bool HasFieldPresent(const base::Value* value, bool* result);
// Parses |value| as int64 and sets it to |result|. If the field does not
// exist, sets 0 to |result| as default value.
// Returns true if |value| is NULL or it is parsed as int64 successfully.
static bool ParseChangestamp(const base::Value* value, int64* result);
// Returns true if |file| has one of the hosted document extensions.
static bool HasHostedDocumentExtension(const FilePath& file);
// The resource ID is used to identify a resource, which looks like:
// file:d41d8cd98f00b204e9800998ecf8
const std::string& resource_id() const { return resource_id_; }
// This is a URL looks like:
// https://docs.google.com/feeds/id/file%3Ad41d8cd98f00b204e9800998ecf8.
// The URL is currently not used.
const std::string& id() const { return id_; }
DriveEntryKind kind() const { return kind_; }
const string16& title() const { return title_; }
base::Time published_time() const { return published_time_; }
base::Time last_viewed_time() const { return last_viewed_time_; }
const std::vector<string16>& labels() const { return labels_; }
// Content URL is the main URL of a resource, used to perform
// non-destructive operations like downloading a file. Search for
// 'content_url' in gdata_wapi_operations.h for details.
const GURL& content_url() const { return content_.url(); }
const std::string& content_mime_type() const { return content_.mime_type(); }
// The feed links contain extra links for revisions and access control,
// etc. Note that links() contain more basic links like edit URL,
// alternative URL, etc.
const ScopedVector<FeedLink>& feed_links() const { return feed_links_; }
// File name (exists only for kinds FILE and PDF).
const string16& filename() const { return filename_; }
// Suggested file name (exists only for kinds FILE and PDF).
const string16& suggested_filename() const { return suggested_filename_; }
// File content MD5 (exists only for kinds FILE and PDF).
const std::string& file_md5() const { return file_md5_; }
// File size (exists only for kinds FILE and PDF).
int64 file_size() const { return file_size_; }
// True if the file or directory is deleted (applicable to change list only).
bool deleted() const { return deleted_ || removed_; }
// Changestamp (exists only for change query results).
// If not exists, defaults to 0.
int64 changestamp() const { return changestamp_; }
// Text version of resource entry kind. Returns an empty string for
// unknown entry kind.
std::string GetEntryKindText() const;
// Returns preferred file extension for hosted documents. If entry is not
// a hosted document, this call returns an empty string.
std::string GetHostedDocumentExtension() const;
// True if resource entry is remotely hosted.
bool is_hosted_document() const {
return (ClassifyEntryKind(kind_) & KIND_OF_HOSTED_DOCUMENT) > 0;
}
// True if resource entry hosted by Google Documents.
bool is_google_document() const {
return (ClassifyEntryKind(kind_) & KIND_OF_GOOGLE_DOCUMENT) > 0;
}
// True if resource entry is hosted by an external application.
bool is_external_document() const {
return (ClassifyEntryKind(kind_) & KIND_OF_EXTERNAL_DOCUMENT) > 0;
}
// True if resource entry is a folder (collection).
bool is_folder() const {
return (ClassifyEntryKind(kind_) & KIND_OF_FOLDER) > 0;
}
// True if resource entry is regular file.
bool is_file() const {
return (ClassifyEntryKind(kind_) & KIND_OF_FILE) > 0;
}
// True if resource entry can't be mapped to the file system.
bool is_special() const {
return !is_file() && !is_folder() && !is_hosted_document();
}
// The following constructs are exposed for unit tests.
// Classes of EntryKind. Used for ClassifyEntryKind().
enum EntryKindClass {
KIND_OF_NONE = 0,
KIND_OF_HOSTED_DOCUMENT = 1,
KIND_OF_GOOGLE_DOCUMENT = 1 << 1,
KIND_OF_EXTERNAL_DOCUMENT = 1 << 2,
KIND_OF_FOLDER = 1 << 3,
KIND_OF_FILE = 1 << 4,
};
// Classifies the EntryKind. The returned value is a bitmask of
// EntryKindClass. For example, DOCUMENT is classified as
// KIND_OF_HOSTED_DOCUMENT and KIND_OF_GOOGLE_DOCUMENT, hence the returned
// value is KIND_OF_HOSTED_DOCUMENT | KIND_OF_GOOGLE_DOCUMENT.
static int ClassifyEntryKind(DriveEntryKind kind);
void set_resource_id(const std::string& resource_id) {
resource_id_ = resource_id;
}
void set_id(const std::string& id) { id_ = id; }
void set_kind(DriveEntryKind kind) { kind_ = kind; }
void set_title(const string16& title) { title_ = title; }
void set_published_time(const base::Time& published_time) {
published_time_ = published_time;
}
void set_last_viewed_time(const base::Time& last_viewed_time) {
last_viewed_time_ = last_viewed_time;
}
void set_labels(const std::vector<string16>& labels) {
labels_ = labels;
}
void set_content(const Content& content) {
content_ = content;
}
void set_feed_links(ScopedVector<FeedLink>* feed_links) {
feed_links_.swap(*feed_links);
}
void set_filename(const string16& filename) { filename_ = filename; }
void set_suggested_filename(const string16& suggested_filename) {
suggested_filename_ = suggested_filename;
}
void set_file_md5(const std::string& file_md5) { file_md5_ = file_md5; }
void set_file_size(int64 file_size) { file_size_ = file_size; }
void set_deleted(bool deleted) { deleted_ = deleted; }
void set_removed(bool removed) { removed_ = removed; }
void set_changestamp(int64 changestamp) { changestamp_ = changestamp; }
private:
friend class base::internal::RepeatedMessageConverter<ResourceEntry>;
friend class ResourceList;
friend class ResumeUploadOperation;
// Fills the remaining fields where JSONValueConverter cannot catch.
void FillRemainingFields();
// Converts categories.term into DriveEntryKind enum.
static DriveEntryKind GetEntryKindFromTerm(const std::string& term);
// Converts |kind| into its text identifier equivalent.
static const char* GetEntryKindDescription(DriveEntryKind kind);
std::string resource_id_;
std::string id_;
DriveEntryKind kind_;
string16 title_;
base::Time published_time_;
// Last viewed value may be unreliable. See: crbug.com/152628.
base::Time last_viewed_time_;
std::vector<string16> labels_;
Content content_;
ScopedVector<FeedLink> feed_links_;
// Optional fields for files only.
string16 filename_;
string16 suggested_filename_;
std::string file_md5_;
int64 file_size_;
bool deleted_;
bool removed_;
int64 changestamp_;
DISALLOW_COPY_AND_ASSIGN(ResourceEntry);
};
// This class represents a list of resource entries with some extra metadata
// such as the root upload URL. The feed is paginated and the rest of the
// feed can be fetched by retrieving the remaining parts of the feed from
// URLs provided by GetNextFeedURL() method.
class ResourceList : public FeedEntry {
public:
ResourceList();
virtual ~ResourceList();
// Extracts "feed" dictionary from the JSON value, and parse the contents,
// using CreateFrom(). Returns NULL on failure. The input JSON data, coming
// from the gdata server, looks like:
//
// {
// "encoding": "UTF-8",
// "feed": { ... }, // This function will extract this and parse.
// "version": "1.0"
// }
static scoped_ptr<ResourceList> ExtractAndParse(const base::Value& value);
// Creates feed from parsed JSON Value. You should call this
// instead of instantiating JSONValueConverter by yourself because
// this method does some post-process for some fields. See
// FillRemainingFields comment and implementation in ResourceEntry
// class for the details.
static scoped_ptr<ResourceList> CreateFrom(const base::Value& value);
// Variant of CreateFrom() above, creates feed from parsed ChangeList.
// TODO(kochi): This should go away soon. http://crbug.com/142293
static scoped_ptr<ResourceList> CreateFromChangeList(
const ChangeList& changelist);
// Registers the mapping between JSON field names and the members in
// this class.
static void RegisterJSONConverter(
base::JSONValueConverter<ResourceList>* converter);
// Returns true and passes|url| of the next feed if the current entry list
// does not completed this feed.
bool GetNextFeedURL(GURL* url) const;
// List of resource entries.
const ScopedVector<ResourceEntry>& entries() const { return entries_; }
ScopedVector<ResourceEntry>* mutable_entries() { return &entries_; }
// Releases entries_ into |entries|. This is a transfer of ownership, so the
// caller is responsible for deleting the elements of |entries|.
void ReleaseEntries(std::vector<ResourceEntry*>* entries);
// Start index of the resource entry list.
int start_index() const { return start_index_; }
// Number of items per feed of the resource entry list.
int items_per_page() const { return items_per_page_; }
// The largest changestamp. Next time the resource list should be fetched
// from this changestamp.
int64 largest_changestamp() const { return largest_changestamp_; }
// Resource entry list title.
const std::string& title() { return title_; }
void set_entries(ScopedVector<ResourceEntry>* entries) {
entries_.swap(*entries);
}
void set_start_index(int start_index) {
start_index_ = start_index;
}
void set_items_per_page(int items_per_page) {
items_per_page_ = items_per_page;
}
void set_title(const std::string& title) {
title_ = title;
}
void set_largest_changestamp(int64 largest_changestamp) {
largest_changestamp_ = largest_changestamp;
}
private:
// Parses and initializes data members from content of |value|.
// Return false if parsing fails.
bool Parse(const base::Value& value);
ScopedVector<ResourceEntry> entries_;
int start_index_;
int items_per_page_;
std::string title_;
int64 largest_changestamp_;
DISALLOW_COPY_AND_ASSIGN(ResourceList);
};
// Metadata representing installed Google Drive application.
class InstalledApp {
public:
typedef std::vector<std::pair<int, GURL> > IconList;
InstalledApp();
virtual ~InstalledApp();
// WebApp name.
const string16& app_name() const { return app_name_; }
// Drive app id
const std::string& app_id() const { return app_id_; }
// Object (file) type name that is generated by this WebApp.
const string16& object_type() const { return object_type_; }
// True if WebApp supports creation of new file instances.
bool supports_create() const { return supports_create_; }
// List of primary mime types supported by this WebApp. Primary status should
// trigger this WebApp becoming the default handler of file instances that
// have these mime types.
const ScopedVector<std::string>& primary_mimetypes() const {
return primary_mimetypes_;
}
// List of secondary mime types supported by this WebApp. Secondary status
// should make this WebApp show up in "Open with..." pop-up menu of the
// default action menu for file with matching mime types.
const ScopedVector<std::string>& secondary_mimetypes() const {
return secondary_mimetypes_;
}
// List of primary file extensions supported by this WebApp. Primary status
// should trigger this WebApp becoming the default handler of file instances
// that match these extensions.
const ScopedVector<std::string>& primary_extensions() const {
return primary_extensions_;
}
// List of secondary file extensions supported by this WebApp. Secondary
// status should make this WebApp show up in "Open with..." pop-up menu of the
// default action menu for file with matching extensions.
const ScopedVector<std::string>& secondary_extensions() const {
return secondary_extensions_;
}
// List of entry links.
const ScopedVector<Link>& links() const { return links_; }
// Returns a list of icons associated with this installed application.
const ScopedVector<AppIcon>& app_icons() const {
return app_icons_;
}
// Convenience function for getting the icon URLs for a particular |category|
// of icon. Icons are returned in a sorted list, from smallest to largest.
IconList GetIconsForCategory(AppIcon::IconCategory category) const;
// Retrieves product URL from the link collection.
GURL GetProductUrl() const;
// Registers the mapping between JSON field names and the members in
// this class.
static void RegisterJSONConverter(
base::JSONValueConverter<InstalledApp>* converter);
void set_app_id(const std::string& app_id) { app_id_ = app_id; }
void set_app_name(const string16& app_name) { app_name_ = app_name; }
void set_object_type(const string16& object_type) {
object_type_ = object_type;
}
void set_supports_create(bool supports_create) {
supports_create_ = supports_create;
}
void set_primary_mimetypes(
ScopedVector<std::string>* primary_mimetypes) {
primary_mimetypes_.swap(*primary_mimetypes);
}
void set_secondary_mimetypes(
ScopedVector<std::string>* secondary_mimetypes) {
secondary_mimetypes_.swap(*secondary_mimetypes);
}
void set_primary_extensions(
ScopedVector<std::string>* primary_extensions) {
primary_extensions_.swap(*primary_extensions);
}
void set_secondary_extensions(
ScopedVector<std::string>* secondary_extensions) {
secondary_extensions_.swap(*secondary_extensions);
}
void set_links(ScopedVector<Link>* links) {
links_.swap(*links);
}
private:
// Extracts "$t" value from the dictionary |value| and returns it in |result|.
// If the string value can't be found, it returns false.
static bool GetValueString(const base::Value* value,
std::string* result);
std::string app_id_;
string16 app_name_;
string16 object_type_;
bool supports_create_;
ScopedVector<std::string> primary_mimetypes_;
ScopedVector<std::string> secondary_mimetypes_;
ScopedVector<std::string> primary_extensions_;
ScopedVector<std::string> secondary_extensions_;
ScopedVector<Link> links_;
ScopedVector<AppIcon> app_icons_;
};
// Account metadata feed represents the metadata object attached to the user's
// account.
class AccountMetadataFeed {
public:
AccountMetadataFeed();
virtual ~AccountMetadataFeed();
// Creates feed from parsed JSON Value. You should call this
// instead of instantiating JSONValueConverter by yourself because
// this method does some post-process for some fields. See
// FillRemainingFields comment and implementation in ResourceEntry
// class for the details.
static scoped_ptr<AccountMetadataFeed> CreateFrom(const base::Value& value);
int64 quota_bytes_total() const {
return quota_bytes_total_;
}
int64 quota_bytes_used() const {
return quota_bytes_used_;
}
int64 largest_changestamp() const {
return largest_changestamp_;
}
const ScopedVector<InstalledApp>& installed_apps() const {
return installed_apps_;
}
void set_quota_bytes_total(int64 quota_bytes_total) {
quota_bytes_total_ = quota_bytes_total;
}
void set_quota_bytes_used(int64 quota_bytes_used) {
quota_bytes_used_ = quota_bytes_used;
}
void set_largest_changestamp(int64 largest_changestamp) {
largest_changestamp_ = largest_changestamp;
}
void set_installed_apps(ScopedVector<InstalledApp>* installed_apps) {
installed_apps_.swap(*installed_apps);
}
// Registers the mapping between JSON field names and the members in
// this class.
static void RegisterJSONConverter(
base::JSONValueConverter<AccountMetadataFeed>* converter);
private:
// Parses and initializes data members from content of |value|.
// Return false if parsing fails.
bool Parse(const base::Value& value);
int64 quota_bytes_total_;
int64 quota_bytes_used_;
int64 largest_changestamp_;
ScopedVector<InstalledApp> installed_apps_;
DISALLOW_COPY_AND_ASSIGN(AccountMetadataFeed);
};
} // namespace google_apis
#endif // CHROME_BROWSER_GOOGLE_APIS_GDATA_WAPI_PARSER_H_
|