Parse TeamDrive resource inside ChangeList.

google_apis/drive/drive_api_parser.cc

 // 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.
 
 #include "google_apis/drive/drive_api_parser.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 10 matching lines @@
 namespace {
 
 const int64_t kUnsetFileSize = -1;
 
 bool CreateFileResourceFromValue(const base::Value* value,
                                  std::unique_ptr<FileResource>* file) {
   *file = FileResource::CreateFrom(*value);
   return !!*file;
 }
 
+bool CreateTeamDriveResourceFromValue(
+    const base::Value* value,
+    std::unique_ptr<TeamDriveResource>* file) {
+  *file = TeamDriveResource::CreateFrom(*value);
+  return !!*file;
+}
+
 // Converts |url_string| to |result|.  Always returns true to be used
 // for JSONValueConverter::RegisterCustomField method.
 // TODO(mukai): make it return false in case of invalid |url_string|.
 bool GetGURLFromString(const base::StringPiece& url_string, GURL* result) {
   *result = GURL(url_string);
   return true;
 }
 
 // Converts |value| to |result|.
 bool GetParentsFromValue(const base::Value* value,
@@ skipping 143 matching lines @@
 const char kCanShare[] = "canShare";
 
 // Files List
 // https://developers.google.com/drive/v2/reference/files/list
 const char kFileListKind[] = "drive#fileList";
 const char kNextLink[] = "nextLink";
 
 // Change Resource
 // https://developers.google.com/drive/v2/reference/changes
 const char kChangeKind[] = "drive#change";
+const char kType[] = "type";
 const char kFileId[] = "fileId";
 const char kDeleted[] = "deleted";
 const char kFile[] = "file";
+const char kTeamDrive[] = "teamDrive";
+const char kTeamDriveId[] = "teamDriveId";
 
 // Changes List
 // https://developers.google.com/drive/v2/reference/changes/list
 const char kChangeListKind[] = "drive#changeList";
 
+// Maps category name to enum ChangeType.
+struct ChangeTypeMap {
+  ChangeResource::ChangeType type;
+  const char* type_name;
+};
+
+constexpr ChangeTypeMap kChangeTypeMap[] = {
+  { ChangeResource::FILE, "file" },
+  { ChangeResource::TEAM_DRIVE, "teamDrive" },
+};
+
 // Maps category name to enum IconCategory.
 struct AppIconCategoryMap {
   DriveAppIcon::IconCategory category;
   const char* category_name;
 };
 
-const AppIconCategoryMap kAppIconCategoryMap[] = {
+constexpr AppIconCategoryMap kAppIconCategoryMap[] = {
   { DriveAppIcon::DOCUMENT, "document" },
   { DriveAppIcon::APPLICATION, "application" },
   { DriveAppIcon::SHARED_DOCUMENT, "documentShared" },
 };
 
 // Checks if the JSON is expected kind.  In Drive API, JSON data structure has
 // |kind| property which denotes the type of the structure (e.g. "drive#file").
 bool IsResourceKindExpected(const base::Value& value,
                             const std::string& expected_kind) {
   const base::DictionaryValue* as_dict = NULL;
@@ skipping 203 matching lines @@
       can_edit_(false),
       can_list_children_(false),
       can_manage_members_(false),
       can_read_revisions_(false),
       can_remove_children_(false),
       can_rename_(false),
       can_rename_team_drive_(false),
       can_share_(false) {
 }
 
+TeamDriveCapabilities::TeamDriveCapabilities(const TeamDriveCapabilities& src) =
+    default;
+
 TeamDriveCapabilities::~TeamDriveCapabilities(){}
 
 // static
 void TeamDriveCapabilities::RegisterJSONConverter(
     base::JSONValueConverter<TeamDriveCapabilities>* converter) {
   converter->RegisterBoolField(kCanAddChildren,
                                &TeamDriveCapabilities::can_add_children_);
   converter->RegisterBoolField(kCanComment,
                                &TeamDriveCapabilities::can_comment_);
   converter->RegisterBoolField(kCanCopy, &TeamDriveCapabilities::can_copy_);
@@ skipping 209 matching lines @@
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid FileList";
     return false;
   }
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ChangeResource implementation
 
-ChangeResource::ChangeResource() : change_id_(0), deleted_(false) {}
+ChangeResource::ChangeResource()
+    : change_id_(0), type_(UNKNOWN), deleted_(false) {}
 
 ChangeResource::~ChangeResource() {}
 
 // static
 void ChangeResource::RegisterJSONConverter(
     base::JSONValueConverter<ChangeResource>* converter) {
   converter->RegisterCustomField<int64_t>(kId, &ChangeResource::change_id_,
                                           &base::StringToInt64);
+  converter->RegisterCustomField<ChangeType>(kType, &ChangeResource::type_,
+                                             &ChangeResource::GetType);
   converter->RegisterStringField(kFileId, &ChangeResource::file_id_);
   converter->RegisterBoolField(kDeleted, &ChangeResource::deleted_);
   converter->RegisterCustomValueField(kFile, &ChangeResource::file_,
                                       &CreateFileResourceFromValue);
   converter->RegisterCustomField<base::Time>(
       kModificationDate, &ChangeResource::modification_date_,
       &util::GetTimeFromString);
+  converter->RegisterStringField(kTeamDriveId, &ChangeResource::team_drive_id_);
+  converter->RegisterCustomValueField(kTeamDrive, &ChangeResource::team_drive_,
+                                      &CreateTeamDriveResourceFromValue);
 }
 
 // static
 std::unique_ptr<ChangeResource> ChangeResource::CreateFrom(
     const base::Value& value) {
   std::unique_ptr<ChangeResource> resource(new ChangeResource());
   if (!IsResourceKindExpected(value, kChangeKind) || !resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid ChangeResource JSON!";
     return std::unique_ptr<ChangeResource>();
   }
   return resource;
 }
 
 bool ChangeResource::Parse(const base::Value& value) {
   base::JSONValueConverter<ChangeResource> converter;
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid ChangeResource";
     return false;
   }
   return true;
 }
 
+// static
+bool ChangeResource::GetType(const base::StringPiece& type_name,
+                             ChangeResource::ChangeType* result) {
+  for (size_t i = 0; i < arraysize(kChangeTypeMap); i++) {
+    if (type_name == kChangeTypeMap[i].type_name) {
+      *result = kChangeTypeMap[i].type;
+      return true;
+    }
+  }
+  DVLOG(1) << "Unknown change type" << type_name;
+  return false;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ChangeList implementation
 
 ChangeList::ChangeList() : largest_change_id_(0) {}
 
 ChangeList::~ChangeList() {}
 
 // static
 void ChangeList::RegisterJSONConverter(
     base::JSONValueConverter<ChangeList>* converter) {
@@ skipping 101 matching lines @@
 bool ImageMediaMetadata::Parse(const base::Value& value) {
   base::JSONValueConverter<ImageMediaMetadata> converter;
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid ImageMediaMetadata.";
     return false;
   }
   return true;
 }
 
 }  // namespace google_apis