OLD | NEW |
| (Empty) |
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 "chrome/browser/google_apis/gdata_wapi_parser.h" | |
6 | |
7 #include <string> | |
8 | |
9 #include "base/files/file_path.h" | |
10 #include "base/json/json_file_value_serializer.h" | |
11 #include "base/logging.h" | |
12 #include "base/time/time.h" | |
13 #include "base/values.h" | |
14 #include "chrome/browser/google_apis/test_util.h" | |
15 #include "chrome/browser/google_apis/time_util.h" | |
16 #include "testing/gtest/include/gtest/gtest.h" | |
17 | |
18 namespace google_apis { | |
19 | |
20 // TODO(nhiroki): Move json files to out of 'chromeos' directory | |
21 // (http://crbug.com/149788). | |
22 // Test document feed parsing. | |
23 TEST(GDataWAPIParserTest, ResourceListJsonParser) { | |
24 std::string error; | |
25 scoped_ptr<base::Value> document = | |
26 test_util::LoadJSONFile("gdata/basic_feed.json"); | |
27 ASSERT_TRUE(document.get()); | |
28 ASSERT_EQ(base::Value::TYPE_DICTIONARY, document->GetType()); | |
29 scoped_ptr<ResourceList> feed(ResourceList::ExtractAndParse(*document)); | |
30 ASSERT_TRUE(feed.get()); | |
31 | |
32 base::Time update_time; | |
33 ASSERT_TRUE(util::GetTimeFromString("2011-12-14T01:03:21.151Z", | |
34 &update_time)); | |
35 | |
36 EXPECT_EQ(1, feed->start_index()); | |
37 EXPECT_EQ(1000, feed->items_per_page()); | |
38 EXPECT_EQ(update_time, feed->updated_time()); | |
39 | |
40 // Check authors. | |
41 ASSERT_EQ(1U, feed->authors().size()); | |
42 EXPECT_EQ("tester", feed->authors()[0]->name()); | |
43 EXPECT_EQ("tester@testing.com", feed->authors()[0]->email()); | |
44 | |
45 // Check links. | |
46 ASSERT_EQ(6U, feed->links().size()); | |
47 const Link* self_link = feed->GetLinkByType(Link::LINK_SELF); | |
48 ASSERT_TRUE(self_link); | |
49 EXPECT_EQ("https://self_link/", self_link->href().spec()); | |
50 EXPECT_EQ("application/atom+xml", self_link->mime_type()); | |
51 | |
52 const Link* resumable_link = | |
53 feed->GetLinkByType(Link::LINK_RESUMABLE_CREATE_MEDIA); | |
54 ASSERT_TRUE(resumable_link); | |
55 EXPECT_EQ("https://resumable_create_media_link/", | |
56 resumable_link->href().spec()); | |
57 EXPECT_EQ("application/atom+xml", resumable_link->mime_type()); | |
58 | |
59 // Check entries. | |
60 ASSERT_EQ(4U, feed->entries().size()); | |
61 | |
62 // Check a folder entry. | |
63 const ResourceEntry* folder_entry = feed->entries()[0]; | |
64 ASSERT_TRUE(folder_entry); | |
65 EXPECT_EQ(ENTRY_KIND_FOLDER, folder_entry->kind()); | |
66 EXPECT_EQ("\"HhMOFgcNHSt7ImBr\"", folder_entry->etag()); | |
67 EXPECT_EQ("folder:sub_sub_directory_folder_id", folder_entry->resource_id()); | |
68 EXPECT_EQ("https://1_folder_id", folder_entry->id()); | |
69 EXPECT_EQ("Entry 1 Title", folder_entry->title()); | |
70 base::Time entry1_update_time; | |
71 base::Time entry1_publish_time; | |
72 ASSERT_TRUE(util::GetTimeFromString("2011-04-01T18:34:08.234Z", | |
73 &entry1_update_time)); | |
74 ASSERT_TRUE(util::GetTimeFromString("2010-11-07T05:03:54.719Z", | |
75 &entry1_publish_time)); | |
76 EXPECT_EQ(entry1_update_time, folder_entry->updated_time()); | |
77 EXPECT_EQ(entry1_publish_time, folder_entry->published_time()); | |
78 | |
79 ASSERT_EQ(1U, folder_entry->authors().size()); | |
80 EXPECT_EQ("entry_tester", folder_entry->authors()[0]->name()); | |
81 EXPECT_EQ("entry_tester@testing.com", folder_entry->authors()[0]->email()); | |
82 EXPECT_EQ("https://1_folder_content_url/", | |
83 folder_entry->download_url().spec()); | |
84 EXPECT_EQ("application/atom+xml;type=feed", | |
85 folder_entry->content_mime_type()); | |
86 | |
87 ASSERT_EQ(1U, folder_entry->resource_links().size()); | |
88 const ResourceLink* feed_link = folder_entry->resource_links()[0]; | |
89 ASSERT_TRUE(feed_link); | |
90 ASSERT_EQ(ResourceLink::FEED_LINK_ACL, feed_link->type()); | |
91 | |
92 const Link* entry1_alternate_link = | |
93 folder_entry->GetLinkByType(Link::LINK_ALTERNATE); | |
94 ASSERT_TRUE(entry1_alternate_link); | |
95 EXPECT_EQ("https://1_folder_alternate_link/", | |
96 entry1_alternate_link->href().spec()); | |
97 EXPECT_EQ("text/html", entry1_alternate_link->mime_type()); | |
98 | |
99 const Link* entry1_edit_link = folder_entry->GetLinkByType(Link::LINK_EDIT); | |
100 ASSERT_TRUE(entry1_edit_link); | |
101 EXPECT_EQ("https://1_edit_link/", entry1_edit_link->href().spec()); | |
102 EXPECT_EQ("application/atom+xml", entry1_edit_link->mime_type()); | |
103 | |
104 // Check a file entry. | |
105 const ResourceEntry* file_entry = feed->entries()[1]; | |
106 ASSERT_TRUE(file_entry); | |
107 EXPECT_EQ(ENTRY_KIND_FILE, file_entry->kind()); | |
108 EXPECT_EQ("filename.m4a", file_entry->filename()); | |
109 EXPECT_EQ("sugg_file_name.m4a", file_entry->suggested_filename()); | |
110 EXPECT_EQ("3b4382ebefec6e743578c76bbd0575ce", file_entry->file_md5()); | |
111 EXPECT_EQ(892721, file_entry->file_size()); | |
112 const Link* file_parent_link = file_entry->GetLinkByType(Link::LINK_PARENT); | |
113 ASSERT_TRUE(file_parent_link); | |
114 EXPECT_EQ("https://file_link_parent/", file_parent_link->href().spec()); | |
115 EXPECT_EQ("application/atom+xml", file_parent_link->mime_type()); | |
116 EXPECT_EQ("Medical", file_parent_link->title()); | |
117 const Link* file_open_with_link = | |
118 file_entry->GetLinkByType(Link::LINK_OPEN_WITH); | |
119 ASSERT_TRUE(file_open_with_link); | |
120 EXPECT_EQ("https://xml_file_entry_open_with_link/", | |
121 file_open_with_link->href().spec()); | |
122 EXPECT_EQ("application/atom+xml", file_open_with_link->mime_type()); | |
123 EXPECT_EQ("the_app_id", file_open_with_link->app_id()); | |
124 EXPECT_EQ(654321, file_entry->changestamp()); | |
125 | |
126 const Link* file_unknown_link = file_entry->GetLinkByType(Link::LINK_UNKNOWN); | |
127 ASSERT_TRUE(file_unknown_link); | |
128 EXPECT_EQ("https://xml_file_fake_entry_open_with_link/", | |
129 file_unknown_link->href().spec()); | |
130 EXPECT_EQ("application/atom+xml", file_unknown_link->mime_type()); | |
131 EXPECT_EQ("", file_unknown_link->app_id()); | |
132 | |
133 // Check a file entry. | |
134 const ResourceEntry* resource_entry = feed->entries()[2]; | |
135 ASSERT_TRUE(resource_entry); | |
136 EXPECT_EQ(ENTRY_KIND_DOCUMENT, resource_entry->kind()); | |
137 EXPECT_TRUE(resource_entry->is_hosted_document()); | |
138 EXPECT_TRUE(resource_entry->is_google_document()); | |
139 EXPECT_FALSE(resource_entry->is_external_document()); | |
140 | |
141 // Check an external document entry. | |
142 const ResourceEntry* app_entry = feed->entries()[3]; | |
143 ASSERT_TRUE(app_entry); | |
144 EXPECT_EQ(ENTRY_KIND_EXTERNAL_APP, app_entry->kind()); | |
145 EXPECT_TRUE(app_entry->is_hosted_document()); | |
146 EXPECT_TRUE(app_entry->is_external_document()); | |
147 EXPECT_FALSE(app_entry->is_google_document()); | |
148 } | |
149 | |
150 | |
151 // Test document feed parsing. | |
152 TEST(GDataWAPIParserTest, ResourceEntryJsonParser) { | |
153 std::string error; | |
154 scoped_ptr<base::Value> document = | |
155 test_util::LoadJSONFile("gdata/file_entry.json"); | |
156 ASSERT_TRUE(document.get()); | |
157 ASSERT_EQ(base::Value::TYPE_DICTIONARY, document->GetType()); | |
158 scoped_ptr<ResourceEntry> entry(ResourceEntry::ExtractAndParse(*document)); | |
159 ASSERT_TRUE(entry.get()); | |
160 | |
161 EXPECT_EQ(ENTRY_KIND_FILE, entry->kind()); | |
162 EXPECT_EQ("\"HhMOFgxXHit7ImBr\"", entry->etag()); | |
163 EXPECT_EQ("file:2_file_resource_id", entry->resource_id()); | |
164 EXPECT_EQ("2_file_id", entry->id()); | |
165 EXPECT_EQ("File 1.mp3", entry->title()); | |
166 base::Time entry1_update_time; | |
167 base::Time entry1_publish_time; | |
168 ASSERT_TRUE(util::GetTimeFromString("2011-12-14T00:40:47.330Z", | |
169 &entry1_update_time)); | |
170 ASSERT_TRUE(util::GetTimeFromString("2011-12-13T00:40:47.330Z", | |
171 &entry1_publish_time)); | |
172 EXPECT_EQ(entry1_update_time, entry->updated_time()); | |
173 EXPECT_EQ(entry1_publish_time, entry->published_time()); | |
174 | |
175 EXPECT_EQ(1U, entry->authors().size()); | |
176 EXPECT_EQ("tester", entry->authors()[0]->name()); | |
177 EXPECT_EQ("tester@testing.com", entry->authors()[0]->email()); | |
178 EXPECT_EQ("https://file_content_url/", | |
179 entry->download_url().spec()); | |
180 EXPECT_EQ("audio/mpeg", | |
181 entry->content_mime_type()); | |
182 | |
183 // Check feed links. | |
184 ASSERT_EQ(1U, entry->resource_links().size()); | |
185 const ResourceLink* feed_link_1 = entry->resource_links()[0]; | |
186 ASSERT_TRUE(feed_link_1); | |
187 EXPECT_EQ(ResourceLink::FEED_LINK_REVISIONS, feed_link_1->type()); | |
188 | |
189 // Check links. | |
190 ASSERT_EQ(8U, entry->links().size()); | |
191 const Link* entry1_alternate_link = | |
192 entry->GetLinkByType(Link::LINK_ALTERNATE); | |
193 ASSERT_TRUE(entry1_alternate_link); | |
194 EXPECT_EQ("https://file_link_alternate/", | |
195 entry1_alternate_link->href().spec()); | |
196 EXPECT_EQ("text/html", entry1_alternate_link->mime_type()); | |
197 | |
198 const Link* entry1_edit_link = entry->GetLinkByType(Link::LINK_EDIT_MEDIA); | |
199 ASSERT_TRUE(entry1_edit_link); | |
200 EXPECT_EQ("https://file_edit_media/", | |
201 entry1_edit_link->href().spec()); | |
202 EXPECT_EQ("audio/mpeg", entry1_edit_link->mime_type()); | |
203 | |
204 const Link* entry1_self_link = entry->GetLinkByType(Link::LINK_SELF); | |
205 ASSERT_TRUE(entry1_self_link); | |
206 EXPECT_EQ("https://file1_link_self/file%3A2_file_resource_id", | |
207 entry1_self_link->href().spec()); | |
208 EXPECT_EQ("application/atom+xml", entry1_self_link->mime_type()); | |
209 EXPECT_EQ("", entry1_self_link->app_id()); | |
210 | |
211 const Link* entry1_open_with_link = | |
212 entry->GetLinkByType(Link::LINK_OPEN_WITH); | |
213 ASSERT_TRUE(entry1_open_with_link); | |
214 EXPECT_EQ("https://entry1_open_with_link/", | |
215 entry1_open_with_link->href().spec()); | |
216 EXPECT_EQ("application/atom+xml", entry1_open_with_link->mime_type()); | |
217 EXPECT_EQ("the_app_id", entry1_open_with_link->app_id()); | |
218 | |
219 const Link* entry1_unknown_link = entry->GetLinkByType(Link::LINK_UNKNOWN); | |
220 ASSERT_TRUE(entry1_unknown_link); | |
221 EXPECT_EQ("https://entry1_fake_entry_open_with_link/", | |
222 entry1_unknown_link->href().spec()); | |
223 EXPECT_EQ("application/atom+xml", entry1_unknown_link->mime_type()); | |
224 EXPECT_EQ("", entry1_unknown_link->app_id()); | |
225 | |
226 // Check a file properties. | |
227 EXPECT_EQ(ENTRY_KIND_FILE, entry->kind()); | |
228 EXPECT_EQ("File 1.mp3", entry->filename()); | |
229 EXPECT_EQ("File 1.mp3", entry->suggested_filename()); | |
230 EXPECT_EQ("3b4382ebefec6e743578c76bbd0575ce", entry->file_md5()); | |
231 EXPECT_EQ(892721, entry->file_size()); | |
232 | |
233 // WAPI doesn't provide image metadata, but these fields are available | |
234 // since this class can wrap data received from Drive API (via a converter). | |
235 EXPECT_EQ(-1, entry->image_width()); | |
236 EXPECT_EQ(-1, entry->image_height()); | |
237 EXPECT_EQ(-1, entry->image_rotation()); | |
238 } | |
239 | |
240 TEST(GDataWAPIParserTest, AccountMetadataParser) { | |
241 scoped_ptr<base::Value> document = | |
242 test_util::LoadJSONFile("gdata/account_metadata.json"); | |
243 ASSERT_TRUE(document.get()); | |
244 base::DictionaryValue* document_dict = NULL; | |
245 base::DictionaryValue* entry_value = NULL; | |
246 ASSERT_TRUE(document->GetAsDictionary(&document_dict)); | |
247 ASSERT_TRUE(document_dict->GetDictionary(std::string("entry"), &entry_value)); | |
248 ASSERT_TRUE(entry_value); | |
249 | |
250 scoped_ptr<AccountMetadata> metadata( | |
251 AccountMetadata::CreateFrom(*document)); | |
252 ASSERT_TRUE(metadata.get()); | |
253 EXPECT_EQ(GG_LONGLONG(6789012345), metadata->quota_bytes_used()); | |
254 EXPECT_EQ(GG_LONGLONG(9876543210), metadata->quota_bytes_total()); | |
255 EXPECT_EQ(654321, metadata->largest_changestamp()); | |
256 EXPECT_EQ(2U, metadata->installed_apps().size()); | |
257 const InstalledApp* first_app = metadata->installed_apps()[0]; | |
258 const InstalledApp* second_app = metadata->installed_apps()[1]; | |
259 | |
260 ASSERT_TRUE(first_app); | |
261 EXPECT_EQ("Drive App 1", first_app->app_name()); | |
262 EXPECT_EQ("Drive App Object 1", first_app->object_type()); | |
263 EXPECT_TRUE(first_app->supports_create()); | |
264 EXPECT_EQ("https://chrome.google.com/webstore/detail/abcdefabcdef", | |
265 first_app->GetProductUrl().spec()); | |
266 | |
267 ASSERT_EQ(2U, first_app->primary_mimetypes().size()); | |
268 EXPECT_EQ("application/test_type_1", | |
269 *first_app->primary_mimetypes()[0]); | |
270 EXPECT_EQ("application/vnd.google-apps.drive-sdk.11111111", | |
271 *first_app->primary_mimetypes()[1]); | |
272 | |
273 ASSERT_EQ(1U, first_app->secondary_mimetypes().size()); | |
274 EXPECT_EQ("image/jpeg", *first_app->secondary_mimetypes()[0]); | |
275 | |
276 ASSERT_EQ(2U, first_app->primary_extensions().size()); | |
277 EXPECT_EQ("ext_1", *first_app->primary_extensions()[0]); | |
278 EXPECT_EQ("ext_2", *first_app->primary_extensions()[1]); | |
279 | |
280 ASSERT_EQ(1U, first_app->secondary_extensions().size()); | |
281 EXPECT_EQ("ext_3", *first_app->secondary_extensions()[0]); | |
282 | |
283 ASSERT_EQ(1U, first_app->app_icons().size()); | |
284 EXPECT_EQ(AppIcon::ICON_DOCUMENT, first_app->app_icons()[0]->category()); | |
285 EXPECT_EQ(16, first_app->app_icons()[0]->icon_side_length()); | |
286 GURL icon_url = first_app->app_icons()[0]->GetIconURL(); | |
287 EXPECT_EQ("https://www.google.com/images/srpr/logo3w.png", icon_url.spec()); | |
288 InstalledApp::IconList icons = | |
289 first_app->GetIconsForCategory(AppIcon::ICON_DOCUMENT); | |
290 EXPECT_EQ("https://www.google.com/images/srpr/logo3w.png", | |
291 icons[0].second.spec()); | |
292 icons = first_app->GetIconsForCategory(AppIcon::ICON_SHARED_DOCUMENT); | |
293 EXPECT_TRUE(icons.empty()); | |
294 | |
295 ASSERT_TRUE(second_app); | |
296 EXPECT_EQ("Drive App 2", second_app->app_name()); | |
297 EXPECT_EQ("Drive App Object 2", second_app->object_type()); | |
298 EXPECT_EQ("https://chrome.google.com/webstore/detail/deadbeefdeadbeef", | |
299 second_app->GetProductUrl().spec()); | |
300 EXPECT_FALSE(second_app->supports_create()); | |
301 EXPECT_EQ(2U, second_app->primary_mimetypes().size()); | |
302 EXPECT_EQ(0U, second_app->secondary_mimetypes().size()); | |
303 EXPECT_EQ(1U, second_app->primary_extensions().size()); | |
304 EXPECT_EQ(0U, second_app->secondary_extensions().size()); | |
305 } | |
306 | |
307 TEST(GDataWAPIParserTest, ClassifyEntryKindByFileExtension) { | |
308 EXPECT_EQ( | |
309 ResourceEntry::KIND_OF_GOOGLE_DOCUMENT | | |
310 ResourceEntry::KIND_OF_HOSTED_DOCUMENT, | |
311 ResourceEntry::ClassifyEntryKindByFileExtension( | |
312 base::FilePath(FILE_PATH_LITERAL("Test.gdoc")))); | |
313 EXPECT_EQ( | |
314 ResourceEntry::KIND_OF_GOOGLE_DOCUMENT | | |
315 ResourceEntry::KIND_OF_HOSTED_DOCUMENT, | |
316 ResourceEntry::ClassifyEntryKindByFileExtension( | |
317 base::FilePath(FILE_PATH_LITERAL("Test.gsheet")))); | |
318 EXPECT_EQ( | |
319 ResourceEntry::KIND_OF_GOOGLE_DOCUMENT | | |
320 ResourceEntry::KIND_OF_HOSTED_DOCUMENT, | |
321 ResourceEntry::ClassifyEntryKindByFileExtension( | |
322 base::FilePath(FILE_PATH_LITERAL("Test.gslides")))); | |
323 EXPECT_EQ( | |
324 ResourceEntry::KIND_OF_GOOGLE_DOCUMENT | | |
325 ResourceEntry::KIND_OF_HOSTED_DOCUMENT, | |
326 ResourceEntry::ClassifyEntryKindByFileExtension( | |
327 base::FilePath(FILE_PATH_LITERAL("Test.gdraw")))); | |
328 EXPECT_EQ( | |
329 ResourceEntry::KIND_OF_GOOGLE_DOCUMENT | | |
330 ResourceEntry::KIND_OF_HOSTED_DOCUMENT, | |
331 ResourceEntry::ClassifyEntryKindByFileExtension( | |
332 base::FilePath(FILE_PATH_LITERAL("Test.gtable")))); | |
333 EXPECT_EQ( | |
334 ResourceEntry::KIND_OF_EXTERNAL_DOCUMENT | | |
335 ResourceEntry::KIND_OF_HOSTED_DOCUMENT, | |
336 ResourceEntry::ClassifyEntryKindByFileExtension( | |
337 base::FilePath(FILE_PATH_LITERAL("Test.glink")))); | |
338 EXPECT_EQ( | |
339 ResourceEntry::KIND_OF_NONE, | |
340 ResourceEntry::ClassifyEntryKindByFileExtension( | |
341 base::FilePath(FILE_PATH_LITERAL("Test.tar.gz")))); | |
342 EXPECT_EQ( | |
343 ResourceEntry::KIND_OF_NONE, | |
344 ResourceEntry::ClassifyEntryKindByFileExtension( | |
345 base::FilePath(FILE_PATH_LITERAL("Test.txt")))); | |
346 EXPECT_EQ( | |
347 ResourceEntry::KIND_OF_NONE, | |
348 ResourceEntry::ClassifyEntryKindByFileExtension( | |
349 base::FilePath(FILE_PATH_LITERAL("Test")))); | |
350 EXPECT_EQ( | |
351 ResourceEntry::KIND_OF_NONE, | |
352 ResourceEntry::ClassifyEntryKindByFileExtension( | |
353 base::FilePath())); | |
354 } | |
355 | |
356 TEST(GDataWAPIParserTest, ResourceEntryClassifyEntryKind) { | |
357 EXPECT_EQ(ResourceEntry::KIND_OF_NONE, | |
358 ResourceEntry::ClassifyEntryKind(ENTRY_KIND_UNKNOWN)); | |
359 EXPECT_EQ(ResourceEntry::KIND_OF_NONE, | |
360 ResourceEntry::ClassifyEntryKind(ENTRY_KIND_ITEM)); | |
361 EXPECT_EQ(ResourceEntry::KIND_OF_NONE, | |
362 ResourceEntry::ClassifyEntryKind(ENTRY_KIND_SITE)); | |
363 EXPECT_EQ(ResourceEntry::KIND_OF_GOOGLE_DOCUMENT | | |
364 ResourceEntry::KIND_OF_HOSTED_DOCUMENT, | |
365 ResourceEntry::ClassifyEntryKind(ENTRY_KIND_DOCUMENT)); | |
366 EXPECT_EQ(ResourceEntry::KIND_OF_GOOGLE_DOCUMENT | | |
367 ResourceEntry::KIND_OF_HOSTED_DOCUMENT, | |
368 ResourceEntry::ClassifyEntryKind(ENTRY_KIND_SPREADSHEET)); | |
369 EXPECT_EQ(ResourceEntry::KIND_OF_GOOGLE_DOCUMENT | | |
370 ResourceEntry::KIND_OF_HOSTED_DOCUMENT, | |
371 ResourceEntry::ClassifyEntryKind(ENTRY_KIND_PRESENTATION)); | |
372 EXPECT_EQ(ResourceEntry::KIND_OF_GOOGLE_DOCUMENT | | |
373 ResourceEntry::KIND_OF_HOSTED_DOCUMENT, | |
374 ResourceEntry::ClassifyEntryKind(ENTRY_KIND_DRAWING)); | |
375 EXPECT_EQ(ResourceEntry::KIND_OF_GOOGLE_DOCUMENT | | |
376 ResourceEntry::KIND_OF_HOSTED_DOCUMENT, | |
377 ResourceEntry::ClassifyEntryKind(ENTRY_KIND_TABLE)); | |
378 EXPECT_EQ(ResourceEntry::KIND_OF_EXTERNAL_DOCUMENT | | |
379 ResourceEntry::KIND_OF_HOSTED_DOCUMENT, | |
380 ResourceEntry::ClassifyEntryKind(ENTRY_KIND_EXTERNAL_APP)); | |
381 EXPECT_EQ(ResourceEntry::KIND_OF_FOLDER, | |
382 ResourceEntry::ClassifyEntryKind(ENTRY_KIND_FOLDER)); | |
383 EXPECT_EQ(ResourceEntry::KIND_OF_FILE, | |
384 ResourceEntry::ClassifyEntryKind(ENTRY_KIND_FILE)); | |
385 EXPECT_EQ(ResourceEntry::KIND_OF_FILE, | |
386 ResourceEntry::ClassifyEntryKind(ENTRY_KIND_PDF)); | |
387 } | |
388 | |
389 } // namespace google_apis | |
OLD | NEW |