Parse TeamDrive resource inside ChangeList.

components/drive/service/fake_drive_service.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 "components/drive/service/fake_drive_service.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 45 matching lines @@
 using google_apis::HTTP_CREATED;
 using google_apis::HTTP_FORBIDDEN;
 using google_apis::HTTP_NOT_FOUND;
 using google_apis::HTTP_NO_CONTENT;
 using google_apis::HTTP_PRECONDITION;
 using google_apis::HTTP_RESUME_INCOMPLETE;
 using google_apis::HTTP_SUCCESS;
 using google_apis::InitiateUploadCallback;
 using google_apis::ParentReference;
 using google_apis::ProgressCallback;
+using google_apis::TeamDriveResource;
 using google_apis::UploadRangeResponse;
 using google_apis::drive::UploadRangeCallback;
 namespace test_util = google_apis::test_util;
 
 namespace drive {
 namespace {
 
 // Returns true if the entry matches with the search query.
 // Supports queries consist of following format.
 // - Phrases quoted by double/single quotes
@@ skipping 754 matching lines @@
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND,
                               base::Passed(std::unique_ptr<FileResource>())));
     return CancelCallback();
   }
 
   // Make a copy and set the new resource ID and the new title.
   std::unique_ptr<EntryInfo> copied_entry(new EntryInfo);
   copied_entry->content_data = entry->content_data;
   copied_entry->share_url = entry->share_url;
+  copied_entry->change_resource.set_type(ChangeResource::FILE);
   copied_entry->change_resource.set_file(
       base::MakeUnique<FileResource>(*entry->change_resource.file()));
 
   ChangeResource* new_change = &copied_entry->change_resource;
   FileResource* new_file = new_change->mutable_file();
   const std::string new_resource_id = GetNewResourceId();
   new_change->set_file_id(new_resource_id);
   new_file->set_file_id(new_resource_id);
   new_file->set_title(new_title);
 
@@ skipping 739 matching lines @@
 
   const std::string resource_id =
       given_resource_id.empty() ? GetNewResourceId() : given_resource_id;
   if (entries_.count(resource_id))
     return NULL;
   GURL upload_url = GURL("https://xxx/upload/" + resource_id);
 
   std::unique_ptr<EntryInfo> new_entry(new EntryInfo);
   ChangeResource* new_change = &new_entry->change_resource;
   FileResource* new_file = new FileResource;
+  new_change->set_type(ChangeResource::FILE);
   new_change->set_file(base::WrapUnique(new_file));
 
   // Set the resource ID and the title
   new_change->set_file_id(resource_id);
   new_file->set_file_id(resource_id);
   new_file->set_title(title);
   // Set the contents, size and MD5 for a file.
   if (content_type != util::kDriveFolderMimeType &&
       !util::IsKnownHostedDocumentMimeType(content_type)) {
     new_entry->content_data = content_data;
@@ skipping 100 matching lines @@
       ++num_entries_matched;
 
     // If |start_offset| is set, exclude the entry if the entry is before the
     // start index. <= instead of < as |num_entries_matched| was
     // already incremented.
     if (start_offset > 0 && num_entries_matched <= start_offset)
       should_exclude = true;
 
     if (!should_exclude) {
       std::unique_ptr<ChangeResource> entry_copied(new ChangeResource);
+      entry_copied->set_type(entry.type());
       entry_copied->set_change_id(entry.change_id());
       entry_copied->set_file_id(entry.file_id());
       entry_copied->set_deleted(entry.is_deleted());
-      if (entry.file()) {
+      if (entry.type() == ChangeResource::FILE && entry.file()) {
         entry_copied->set_file(base::MakeUnique<FileResource>(*entry.file()));
       }
+      if (entry.type() == ChangeResource::TEAM_DRIVE && entry.team_drive()) {
+        entry_copied->set_team_drive(
+            base::MakeUnique<TeamDriveResource>(*entry.team_drive()));
+      }
       entry_copied->set_modification_date(entry.modification_date());
       entries.push_back(std::move(entry_copied));
     }
   }
 
   std::unique_ptr<ChangeList> change_list(new ChangeList);
   if (start_changestamp > 0 && start_offset == 0) {
     change_list->set_largest_change_id(about_resource_->largest_change_id());
   }
 
@@ skipping 58 matching lines @@
   NOTREACHED();
   return std::unique_ptr<BatchRequestConfiguratorInterface>();
 }
 
 void FakeDriveService::NotifyObservers() {
   for (auto& observer : change_observers_)
     observer.OnNewChangeAvailable();
 }
 
 }  // namespace drive